Line data Source code
1 : /* client functions auto-generated by pidl */
2 :
3 : #include "includes.h"
4 : #include <tevent.h>
5 : #include "lib/util/tevent_ntstatus.h"
6 : #include "bin/default/librpc/gen_ndr/ndr_clusapi.h"
7 : #include "bin/default/librpc/gen_ndr/ndr_clusapi_c.h"
8 :
9 : /* clusapi - client functions generated by pidl */
10 :
11 : struct dcerpc_clusapi_OpenCluster_r_state {
12 : TALLOC_CTX *out_mem_ctx;
13 : };
14 :
15 : static void dcerpc_clusapi_OpenCluster_r_done(struct tevent_req *subreq);
16 :
17 0 : struct tevent_req *dcerpc_clusapi_OpenCluster_r_send(TALLOC_CTX *mem_ctx,
18 : struct tevent_context *ev,
19 : struct dcerpc_binding_handle *h,
20 : struct clusapi_OpenCluster *r)
21 : {
22 : struct tevent_req *req;
23 : struct dcerpc_clusapi_OpenCluster_r_state *state;
24 : struct tevent_req *subreq;
25 :
26 0 : req = tevent_req_create(mem_ctx, &state,
27 : struct dcerpc_clusapi_OpenCluster_r_state);
28 0 : if (req == NULL) {
29 0 : return NULL;
30 : }
31 :
32 0 : state->out_mem_ctx = talloc_new(state);
33 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34 0 : return tevent_req_post(req, ev);
35 : }
36 :
37 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
38 : NULL, &ndr_table_clusapi,
39 0 : NDR_CLUSAPI_OPENCLUSTER, state->out_mem_ctx, r);
40 0 : if (tevent_req_nomem(subreq, req)) {
41 0 : return tevent_req_post(req, ev);
42 : }
43 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenCluster_r_done, req);
44 :
45 0 : return req;
46 : }
47 :
48 0 : static void dcerpc_clusapi_OpenCluster_r_done(struct tevent_req *subreq)
49 : {
50 0 : struct tevent_req *req =
51 0 : tevent_req_callback_data(subreq,
52 : struct tevent_req);
53 : NTSTATUS status;
54 :
55 0 : status = dcerpc_binding_handle_call_recv(subreq);
56 0 : TALLOC_FREE(subreq);
57 0 : if (tevent_req_nterror(req, status)) {
58 0 : return;
59 : }
60 :
61 0 : tevent_req_done(req);
62 : }
63 :
64 0 : NTSTATUS dcerpc_clusapi_OpenCluster_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
65 : {
66 0 : struct dcerpc_clusapi_OpenCluster_r_state *state =
67 0 : tevent_req_data(req,
68 : struct dcerpc_clusapi_OpenCluster_r_state);
69 : NTSTATUS status;
70 :
71 0 : if (tevent_req_is_nterror(req, &status)) {
72 0 : tevent_req_received(req);
73 0 : return status;
74 : }
75 :
76 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
77 :
78 0 : tevent_req_received(req);
79 0 : return NT_STATUS_OK;
80 : }
81 :
82 0 : NTSTATUS dcerpc_clusapi_OpenCluster_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenCluster *r)
83 : {
84 : NTSTATUS status;
85 :
86 0 : status = dcerpc_binding_handle_call(h,
87 : NULL, &ndr_table_clusapi,
88 : NDR_CLUSAPI_OPENCLUSTER, mem_ctx, r);
89 :
90 0 : return status;
91 : }
92 :
93 : struct dcerpc_clusapi_OpenCluster_state {
94 : struct clusapi_OpenCluster orig;
95 : struct clusapi_OpenCluster tmp;
96 : TALLOC_CTX *out_mem_ctx;
97 : };
98 :
99 : static void dcerpc_clusapi_OpenCluster_done(struct tevent_req *subreq);
100 :
101 0 : struct tevent_req *dcerpc_clusapi_OpenCluster_send(TALLOC_CTX *mem_ctx,
102 : struct tevent_context *ev,
103 : struct dcerpc_binding_handle *h,
104 : WERROR *_Status /* [out] [ref] */,
105 : struct policy_handle *_Cluster /* [out] [ref] */)
106 : {
107 : struct tevent_req *req;
108 : struct dcerpc_clusapi_OpenCluster_state *state;
109 : struct tevent_req *subreq;
110 :
111 0 : req = tevent_req_create(mem_ctx, &state,
112 : struct dcerpc_clusapi_OpenCluster_state);
113 0 : if (req == NULL) {
114 0 : return NULL;
115 : }
116 0 : state->out_mem_ctx = NULL;
117 :
118 : /* In parameters */
119 :
120 : /* Out parameters */
121 0 : state->orig.out.Status = _Status;
122 0 : state->orig.out.Cluster = _Cluster;
123 :
124 0 : state->out_mem_ctx = talloc_named_const(state, 0,
125 : "dcerpc_clusapi_OpenCluster_out_memory");
126 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
127 0 : return tevent_req_post(req, ev);
128 : }
129 :
130 : /* make a temporary copy, that we pass to the dispatch function */
131 0 : state->tmp = state->orig;
132 :
133 0 : subreq = dcerpc_clusapi_OpenCluster_r_send(state, ev, h, &state->tmp);
134 0 : if (tevent_req_nomem(subreq, req)) {
135 0 : return tevent_req_post(req, ev);
136 : }
137 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenCluster_done, req);
138 0 : return req;
139 : }
140 :
141 0 : static void dcerpc_clusapi_OpenCluster_done(struct tevent_req *subreq)
142 : {
143 0 : struct tevent_req *req = tevent_req_callback_data(
144 : subreq, struct tevent_req);
145 0 : struct dcerpc_clusapi_OpenCluster_state *state = tevent_req_data(
146 : req, struct dcerpc_clusapi_OpenCluster_state);
147 : NTSTATUS status;
148 : TALLOC_CTX *mem_ctx;
149 :
150 0 : if (state->out_mem_ctx) {
151 0 : mem_ctx = state->out_mem_ctx;
152 : } else {
153 0 : mem_ctx = state;
154 : }
155 :
156 0 : status = dcerpc_clusapi_OpenCluster_r_recv(subreq, mem_ctx);
157 0 : TALLOC_FREE(subreq);
158 0 : if (tevent_req_nterror(req, status)) {
159 0 : return;
160 : }
161 :
162 : /* Copy out parameters */
163 0 : *state->orig.out.Status = *state->tmp.out.Status;
164 0 : *state->orig.out.Cluster = *state->tmp.out.Cluster;
165 :
166 : /* Reset temporary structure */
167 0 : NDR_ZERO_STRUCT(state->tmp);
168 :
169 0 : tevent_req_done(req);
170 : }
171 :
172 0 : NTSTATUS dcerpc_clusapi_OpenCluster_recv(struct tevent_req *req,
173 : TALLOC_CTX *mem_ctx)
174 : {
175 0 : struct dcerpc_clusapi_OpenCluster_state *state = tevent_req_data(
176 : req, struct dcerpc_clusapi_OpenCluster_state);
177 : NTSTATUS status;
178 :
179 0 : if (tevent_req_is_nterror(req, &status)) {
180 0 : tevent_req_received(req);
181 0 : return status;
182 : }
183 :
184 : /* Steal possible out parameters to the callers context */
185 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
186 :
187 0 : tevent_req_received(req);
188 0 : return NT_STATUS_OK;
189 : }
190 :
191 0 : NTSTATUS dcerpc_clusapi_OpenCluster(struct dcerpc_binding_handle *h,
192 : TALLOC_CTX *mem_ctx,
193 : WERROR *_Status /* [out] [ref] */,
194 : struct policy_handle *_Cluster /* [out] [ref] */)
195 : {
196 : struct clusapi_OpenCluster r;
197 : NTSTATUS status;
198 :
199 : /* In parameters */
200 :
201 : /* Out parameters */
202 0 : r.out.Status = _Status;
203 0 : r.out.Cluster = _Cluster;
204 :
205 0 : status = dcerpc_clusapi_OpenCluster_r(h, mem_ctx, &r);
206 0 : if (!NT_STATUS_IS_OK(status)) {
207 0 : return status;
208 : }
209 :
210 : /* Return variables */
211 0 : *_Status = *r.out.Status;
212 0 : *_Cluster = *r.out.Cluster;
213 :
214 : /* Return result */
215 :
216 0 : return NT_STATUS_OK;
217 : }
218 :
219 : struct dcerpc_clusapi_CloseCluster_r_state {
220 : TALLOC_CTX *out_mem_ctx;
221 : };
222 :
223 : static void dcerpc_clusapi_CloseCluster_r_done(struct tevent_req *subreq);
224 :
225 0 : struct tevent_req *dcerpc_clusapi_CloseCluster_r_send(TALLOC_CTX *mem_ctx,
226 : struct tevent_context *ev,
227 : struct dcerpc_binding_handle *h,
228 : struct clusapi_CloseCluster *r)
229 : {
230 : struct tevent_req *req;
231 : struct dcerpc_clusapi_CloseCluster_r_state *state;
232 : struct tevent_req *subreq;
233 :
234 0 : req = tevent_req_create(mem_ctx, &state,
235 : struct dcerpc_clusapi_CloseCluster_r_state);
236 0 : if (req == NULL) {
237 0 : return NULL;
238 : }
239 :
240 0 : state->out_mem_ctx = talloc_new(state);
241 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
242 0 : return tevent_req_post(req, ev);
243 : }
244 :
245 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
246 : NULL, &ndr_table_clusapi,
247 0 : NDR_CLUSAPI_CLOSECLUSTER, state->out_mem_ctx, r);
248 0 : if (tevent_req_nomem(subreq, req)) {
249 0 : return tevent_req_post(req, ev);
250 : }
251 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseCluster_r_done, req);
252 :
253 0 : return req;
254 : }
255 :
256 0 : static void dcerpc_clusapi_CloseCluster_r_done(struct tevent_req *subreq)
257 : {
258 0 : struct tevent_req *req =
259 0 : tevent_req_callback_data(subreq,
260 : struct tevent_req);
261 : NTSTATUS status;
262 :
263 0 : status = dcerpc_binding_handle_call_recv(subreq);
264 0 : TALLOC_FREE(subreq);
265 0 : if (tevent_req_nterror(req, status)) {
266 0 : return;
267 : }
268 :
269 0 : tevent_req_done(req);
270 : }
271 :
272 0 : NTSTATUS dcerpc_clusapi_CloseCluster_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
273 : {
274 0 : struct dcerpc_clusapi_CloseCluster_r_state *state =
275 0 : tevent_req_data(req,
276 : struct dcerpc_clusapi_CloseCluster_r_state);
277 : NTSTATUS status;
278 :
279 0 : if (tevent_req_is_nterror(req, &status)) {
280 0 : tevent_req_received(req);
281 0 : return status;
282 : }
283 :
284 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
285 :
286 0 : tevent_req_received(req);
287 0 : return NT_STATUS_OK;
288 : }
289 :
290 0 : NTSTATUS dcerpc_clusapi_CloseCluster_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseCluster *r)
291 : {
292 : NTSTATUS status;
293 :
294 0 : status = dcerpc_binding_handle_call(h,
295 : NULL, &ndr_table_clusapi,
296 : NDR_CLUSAPI_CLOSECLUSTER, mem_ctx, r);
297 :
298 0 : return status;
299 : }
300 :
301 : struct dcerpc_clusapi_CloseCluster_state {
302 : struct clusapi_CloseCluster orig;
303 : struct clusapi_CloseCluster tmp;
304 : TALLOC_CTX *out_mem_ctx;
305 : };
306 :
307 : static void dcerpc_clusapi_CloseCluster_done(struct tevent_req *subreq);
308 :
309 0 : struct tevent_req *dcerpc_clusapi_CloseCluster_send(TALLOC_CTX *mem_ctx,
310 : struct tevent_context *ev,
311 : struct dcerpc_binding_handle *h,
312 : struct policy_handle *_Cluster /* [in,out] [ref] */)
313 : {
314 : struct tevent_req *req;
315 : struct dcerpc_clusapi_CloseCluster_state *state;
316 : struct tevent_req *subreq;
317 :
318 0 : req = tevent_req_create(mem_ctx, &state,
319 : struct dcerpc_clusapi_CloseCluster_state);
320 0 : if (req == NULL) {
321 0 : return NULL;
322 : }
323 0 : state->out_mem_ctx = NULL;
324 :
325 : /* In parameters */
326 0 : state->orig.in.Cluster = _Cluster;
327 :
328 : /* Out parameters */
329 0 : state->orig.out.Cluster = _Cluster;
330 :
331 : /* Result */
332 0 : NDR_ZERO_STRUCT(state->orig.out.result);
333 :
334 0 : state->out_mem_ctx = talloc_named_const(state, 0,
335 : "dcerpc_clusapi_CloseCluster_out_memory");
336 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
337 0 : return tevent_req_post(req, ev);
338 : }
339 :
340 : /* make a temporary copy, that we pass to the dispatch function */
341 0 : state->tmp = state->orig;
342 :
343 0 : subreq = dcerpc_clusapi_CloseCluster_r_send(state, ev, h, &state->tmp);
344 0 : if (tevent_req_nomem(subreq, req)) {
345 0 : return tevent_req_post(req, ev);
346 : }
347 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseCluster_done, req);
348 0 : return req;
349 : }
350 :
351 0 : static void dcerpc_clusapi_CloseCluster_done(struct tevent_req *subreq)
352 : {
353 0 : struct tevent_req *req = tevent_req_callback_data(
354 : subreq, struct tevent_req);
355 0 : struct dcerpc_clusapi_CloseCluster_state *state = tevent_req_data(
356 : req, struct dcerpc_clusapi_CloseCluster_state);
357 : NTSTATUS status;
358 : TALLOC_CTX *mem_ctx;
359 :
360 0 : if (state->out_mem_ctx) {
361 0 : mem_ctx = state->out_mem_ctx;
362 : } else {
363 0 : mem_ctx = state;
364 : }
365 :
366 0 : status = dcerpc_clusapi_CloseCluster_r_recv(subreq, mem_ctx);
367 0 : TALLOC_FREE(subreq);
368 0 : if (tevent_req_nterror(req, status)) {
369 0 : return;
370 : }
371 :
372 : /* Copy out parameters */
373 0 : *state->orig.out.Cluster = *state->tmp.out.Cluster;
374 :
375 : /* Copy result */
376 0 : state->orig.out.result = state->tmp.out.result;
377 :
378 : /* Reset temporary structure */
379 0 : NDR_ZERO_STRUCT(state->tmp);
380 :
381 0 : tevent_req_done(req);
382 : }
383 :
384 0 : NTSTATUS dcerpc_clusapi_CloseCluster_recv(struct tevent_req *req,
385 : TALLOC_CTX *mem_ctx,
386 : WERROR *result)
387 : {
388 0 : struct dcerpc_clusapi_CloseCluster_state *state = tevent_req_data(
389 : req, struct dcerpc_clusapi_CloseCluster_state);
390 : NTSTATUS status;
391 :
392 0 : if (tevent_req_is_nterror(req, &status)) {
393 0 : tevent_req_received(req);
394 0 : return status;
395 : }
396 :
397 : /* Steal possible out parameters to the callers context */
398 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
399 :
400 : /* Return result */
401 0 : *result = state->orig.out.result;
402 :
403 0 : tevent_req_received(req);
404 0 : return NT_STATUS_OK;
405 : }
406 :
407 0 : NTSTATUS dcerpc_clusapi_CloseCluster(struct dcerpc_binding_handle *h,
408 : TALLOC_CTX *mem_ctx,
409 : struct policy_handle *_Cluster /* [in,out] [ref] */,
410 : WERROR *result)
411 : {
412 : struct clusapi_CloseCluster r;
413 : NTSTATUS status;
414 :
415 : /* In parameters */
416 0 : r.in.Cluster = _Cluster;
417 :
418 : /* Out parameters */
419 0 : r.out.Cluster = _Cluster;
420 :
421 : /* Result */
422 0 : NDR_ZERO_STRUCT(r.out.result);
423 :
424 0 : status = dcerpc_clusapi_CloseCluster_r(h, mem_ctx, &r);
425 0 : if (!NT_STATUS_IS_OK(status)) {
426 0 : return status;
427 : }
428 :
429 : /* Return variables */
430 0 : *_Cluster = *r.out.Cluster;
431 :
432 : /* Return result */
433 0 : *result = r.out.result;
434 :
435 0 : return NT_STATUS_OK;
436 : }
437 :
438 : struct dcerpc_clusapi_SetClusterName_r_state {
439 : TALLOC_CTX *out_mem_ctx;
440 : };
441 :
442 : static void dcerpc_clusapi_SetClusterName_r_done(struct tevent_req *subreq);
443 :
444 0 : struct tevent_req *dcerpc_clusapi_SetClusterName_r_send(TALLOC_CTX *mem_ctx,
445 : struct tevent_context *ev,
446 : struct dcerpc_binding_handle *h,
447 : struct clusapi_SetClusterName *r)
448 : {
449 : struct tevent_req *req;
450 : struct dcerpc_clusapi_SetClusterName_r_state *state;
451 : struct tevent_req *subreq;
452 :
453 0 : req = tevent_req_create(mem_ctx, &state,
454 : struct dcerpc_clusapi_SetClusterName_r_state);
455 0 : if (req == NULL) {
456 0 : return NULL;
457 : }
458 :
459 0 : state->out_mem_ctx = talloc_new(state);
460 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
461 0 : return tevent_req_post(req, ev);
462 : }
463 :
464 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
465 : NULL, &ndr_table_clusapi,
466 0 : NDR_CLUSAPI_SETCLUSTERNAME, state->out_mem_ctx, r);
467 0 : if (tevent_req_nomem(subreq, req)) {
468 0 : return tevent_req_post(req, ev);
469 : }
470 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetClusterName_r_done, req);
471 :
472 0 : return req;
473 : }
474 :
475 0 : static void dcerpc_clusapi_SetClusterName_r_done(struct tevent_req *subreq)
476 : {
477 0 : struct tevent_req *req =
478 0 : tevent_req_callback_data(subreq,
479 : struct tevent_req);
480 : NTSTATUS status;
481 :
482 0 : status = dcerpc_binding_handle_call_recv(subreq);
483 0 : TALLOC_FREE(subreq);
484 0 : if (tevent_req_nterror(req, status)) {
485 0 : return;
486 : }
487 :
488 0 : tevent_req_done(req);
489 : }
490 :
491 0 : NTSTATUS dcerpc_clusapi_SetClusterName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
492 : {
493 0 : struct dcerpc_clusapi_SetClusterName_r_state *state =
494 0 : tevent_req_data(req,
495 : struct dcerpc_clusapi_SetClusterName_r_state);
496 : NTSTATUS status;
497 :
498 0 : if (tevent_req_is_nterror(req, &status)) {
499 0 : tevent_req_received(req);
500 0 : return status;
501 : }
502 :
503 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
504 :
505 0 : tevent_req_received(req);
506 0 : return NT_STATUS_OK;
507 : }
508 :
509 0 : NTSTATUS dcerpc_clusapi_SetClusterName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetClusterName *r)
510 : {
511 : NTSTATUS status;
512 :
513 0 : status = dcerpc_binding_handle_call(h,
514 : NULL, &ndr_table_clusapi,
515 : NDR_CLUSAPI_SETCLUSTERNAME, mem_ctx, r);
516 :
517 0 : return status;
518 : }
519 :
520 : struct dcerpc_clusapi_SetClusterName_state {
521 : struct clusapi_SetClusterName orig;
522 : struct clusapi_SetClusterName tmp;
523 : TALLOC_CTX *out_mem_ctx;
524 : };
525 :
526 : static void dcerpc_clusapi_SetClusterName_done(struct tevent_req *subreq);
527 :
528 0 : struct tevent_req *dcerpc_clusapi_SetClusterName_send(TALLOC_CTX *mem_ctx,
529 : struct tevent_context *ev,
530 : struct dcerpc_binding_handle *h,
531 : const char *_NewClusterName /* [in] [charset(UTF16),ref] */,
532 : WERROR *_rpc_status /* [out] [ref] */)
533 : {
534 : struct tevent_req *req;
535 : struct dcerpc_clusapi_SetClusterName_state *state;
536 : struct tevent_req *subreq;
537 :
538 0 : req = tevent_req_create(mem_ctx, &state,
539 : struct dcerpc_clusapi_SetClusterName_state);
540 0 : if (req == NULL) {
541 0 : return NULL;
542 : }
543 0 : state->out_mem_ctx = NULL;
544 :
545 : /* In parameters */
546 0 : state->orig.in.NewClusterName = _NewClusterName;
547 :
548 : /* Out parameters */
549 0 : state->orig.out.rpc_status = _rpc_status;
550 :
551 : /* Result */
552 0 : NDR_ZERO_STRUCT(state->orig.out.result);
553 :
554 0 : state->out_mem_ctx = talloc_named_const(state, 0,
555 : "dcerpc_clusapi_SetClusterName_out_memory");
556 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
557 0 : return tevent_req_post(req, ev);
558 : }
559 :
560 : /* make a temporary copy, that we pass to the dispatch function */
561 0 : state->tmp = state->orig;
562 :
563 0 : subreq = dcerpc_clusapi_SetClusterName_r_send(state, ev, h, &state->tmp);
564 0 : if (tevent_req_nomem(subreq, req)) {
565 0 : return tevent_req_post(req, ev);
566 : }
567 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetClusterName_done, req);
568 0 : return req;
569 : }
570 :
571 0 : static void dcerpc_clusapi_SetClusterName_done(struct tevent_req *subreq)
572 : {
573 0 : struct tevent_req *req = tevent_req_callback_data(
574 : subreq, struct tevent_req);
575 0 : struct dcerpc_clusapi_SetClusterName_state *state = tevent_req_data(
576 : req, struct dcerpc_clusapi_SetClusterName_state);
577 : NTSTATUS status;
578 : TALLOC_CTX *mem_ctx;
579 :
580 0 : if (state->out_mem_ctx) {
581 0 : mem_ctx = state->out_mem_ctx;
582 : } else {
583 0 : mem_ctx = state;
584 : }
585 :
586 0 : status = dcerpc_clusapi_SetClusterName_r_recv(subreq, mem_ctx);
587 0 : TALLOC_FREE(subreq);
588 0 : if (tevent_req_nterror(req, status)) {
589 0 : return;
590 : }
591 :
592 : /* Copy out parameters */
593 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
594 :
595 : /* Copy result */
596 0 : state->orig.out.result = state->tmp.out.result;
597 :
598 : /* Reset temporary structure */
599 0 : NDR_ZERO_STRUCT(state->tmp);
600 :
601 0 : tevent_req_done(req);
602 : }
603 :
604 0 : NTSTATUS dcerpc_clusapi_SetClusterName_recv(struct tevent_req *req,
605 : TALLOC_CTX *mem_ctx,
606 : WERROR *result)
607 : {
608 0 : struct dcerpc_clusapi_SetClusterName_state *state = tevent_req_data(
609 : req, struct dcerpc_clusapi_SetClusterName_state);
610 : NTSTATUS status;
611 :
612 0 : if (tevent_req_is_nterror(req, &status)) {
613 0 : tevent_req_received(req);
614 0 : return status;
615 : }
616 :
617 : /* Steal possible out parameters to the callers context */
618 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
619 :
620 : /* Return result */
621 0 : *result = state->orig.out.result;
622 :
623 0 : tevent_req_received(req);
624 0 : return NT_STATUS_OK;
625 : }
626 :
627 0 : NTSTATUS dcerpc_clusapi_SetClusterName(struct dcerpc_binding_handle *h,
628 : TALLOC_CTX *mem_ctx,
629 : const char *_NewClusterName /* [in] [charset(UTF16),ref] */,
630 : WERROR *_rpc_status /* [out] [ref] */,
631 : WERROR *result)
632 : {
633 : struct clusapi_SetClusterName r;
634 : NTSTATUS status;
635 :
636 : /* In parameters */
637 0 : r.in.NewClusterName = _NewClusterName;
638 :
639 : /* Out parameters */
640 0 : r.out.rpc_status = _rpc_status;
641 :
642 : /* Result */
643 0 : NDR_ZERO_STRUCT(r.out.result);
644 :
645 0 : status = dcerpc_clusapi_SetClusterName_r(h, mem_ctx, &r);
646 0 : if (!NT_STATUS_IS_OK(status)) {
647 0 : return status;
648 : }
649 :
650 : /* Return variables */
651 0 : *_rpc_status = *r.out.rpc_status;
652 :
653 : /* Return result */
654 0 : *result = r.out.result;
655 :
656 0 : return NT_STATUS_OK;
657 : }
658 :
659 : struct dcerpc_clusapi_GetClusterName_r_state {
660 : TALLOC_CTX *out_mem_ctx;
661 : };
662 :
663 : static void dcerpc_clusapi_GetClusterName_r_done(struct tevent_req *subreq);
664 :
665 0 : struct tevent_req *dcerpc_clusapi_GetClusterName_r_send(TALLOC_CTX *mem_ctx,
666 : struct tevent_context *ev,
667 : struct dcerpc_binding_handle *h,
668 : struct clusapi_GetClusterName *r)
669 : {
670 : struct tevent_req *req;
671 : struct dcerpc_clusapi_GetClusterName_r_state *state;
672 : struct tevent_req *subreq;
673 :
674 0 : req = tevent_req_create(mem_ctx, &state,
675 : struct dcerpc_clusapi_GetClusterName_r_state);
676 0 : if (req == NULL) {
677 0 : return NULL;
678 : }
679 :
680 0 : state->out_mem_ctx = talloc_new(state);
681 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
682 0 : return tevent_req_post(req, ev);
683 : }
684 :
685 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
686 : NULL, &ndr_table_clusapi,
687 0 : NDR_CLUSAPI_GETCLUSTERNAME, state->out_mem_ctx, r);
688 0 : if (tevent_req_nomem(subreq, req)) {
689 0 : return tevent_req_post(req, ev);
690 : }
691 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterName_r_done, req);
692 :
693 0 : return req;
694 : }
695 :
696 0 : static void dcerpc_clusapi_GetClusterName_r_done(struct tevent_req *subreq)
697 : {
698 0 : struct tevent_req *req =
699 0 : tevent_req_callback_data(subreq,
700 : struct tevent_req);
701 : NTSTATUS status;
702 :
703 0 : status = dcerpc_binding_handle_call_recv(subreq);
704 0 : TALLOC_FREE(subreq);
705 0 : if (tevent_req_nterror(req, status)) {
706 0 : return;
707 : }
708 :
709 0 : tevent_req_done(req);
710 : }
711 :
712 0 : NTSTATUS dcerpc_clusapi_GetClusterName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
713 : {
714 0 : struct dcerpc_clusapi_GetClusterName_r_state *state =
715 0 : tevent_req_data(req,
716 : struct dcerpc_clusapi_GetClusterName_r_state);
717 : NTSTATUS status;
718 :
719 0 : if (tevent_req_is_nterror(req, &status)) {
720 0 : tevent_req_received(req);
721 0 : return status;
722 : }
723 :
724 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
725 :
726 0 : tevent_req_received(req);
727 0 : return NT_STATUS_OK;
728 : }
729 :
730 0 : NTSTATUS dcerpc_clusapi_GetClusterName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetClusterName *r)
731 : {
732 : NTSTATUS status;
733 :
734 0 : status = dcerpc_binding_handle_call(h,
735 : NULL, &ndr_table_clusapi,
736 : NDR_CLUSAPI_GETCLUSTERNAME, mem_ctx, r);
737 :
738 0 : return status;
739 : }
740 :
741 : struct dcerpc_clusapi_GetClusterName_state {
742 : struct clusapi_GetClusterName orig;
743 : struct clusapi_GetClusterName tmp;
744 : TALLOC_CTX *out_mem_ctx;
745 : };
746 :
747 : static void dcerpc_clusapi_GetClusterName_done(struct tevent_req *subreq);
748 :
749 0 : struct tevent_req *dcerpc_clusapi_GetClusterName_send(TALLOC_CTX *mem_ctx,
750 : struct tevent_context *ev,
751 : struct dcerpc_binding_handle *h,
752 : const char **_ClusterName /* [out] [charset(UTF16),ref] */,
753 : const char **_NodeName /* [out] [charset(UTF16),ref] */)
754 : {
755 : struct tevent_req *req;
756 : struct dcerpc_clusapi_GetClusterName_state *state;
757 : struct tevent_req *subreq;
758 :
759 0 : req = tevent_req_create(mem_ctx, &state,
760 : struct dcerpc_clusapi_GetClusterName_state);
761 0 : if (req == NULL) {
762 0 : return NULL;
763 : }
764 0 : state->out_mem_ctx = NULL;
765 :
766 : /* In parameters */
767 :
768 : /* Out parameters */
769 0 : state->orig.out.ClusterName = _ClusterName;
770 0 : state->orig.out.NodeName = _NodeName;
771 :
772 : /* Result */
773 0 : NDR_ZERO_STRUCT(state->orig.out.result);
774 :
775 0 : state->out_mem_ctx = talloc_named_const(state, 0,
776 : "dcerpc_clusapi_GetClusterName_out_memory");
777 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
778 0 : return tevent_req_post(req, ev);
779 : }
780 :
781 : /* make a temporary copy, that we pass to the dispatch function */
782 0 : state->tmp = state->orig;
783 :
784 0 : subreq = dcerpc_clusapi_GetClusterName_r_send(state, ev, h, &state->tmp);
785 0 : if (tevent_req_nomem(subreq, req)) {
786 0 : return tevent_req_post(req, ev);
787 : }
788 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterName_done, req);
789 0 : return req;
790 : }
791 :
792 0 : static void dcerpc_clusapi_GetClusterName_done(struct tevent_req *subreq)
793 : {
794 0 : struct tevent_req *req = tevent_req_callback_data(
795 : subreq, struct tevent_req);
796 0 : struct dcerpc_clusapi_GetClusterName_state *state = tevent_req_data(
797 : req, struct dcerpc_clusapi_GetClusterName_state);
798 : NTSTATUS status;
799 : TALLOC_CTX *mem_ctx;
800 :
801 0 : if (state->out_mem_ctx) {
802 0 : mem_ctx = state->out_mem_ctx;
803 : } else {
804 0 : mem_ctx = state;
805 : }
806 :
807 0 : status = dcerpc_clusapi_GetClusterName_r_recv(subreq, mem_ctx);
808 0 : TALLOC_FREE(subreq);
809 0 : if (tevent_req_nterror(req, status)) {
810 0 : return;
811 : }
812 :
813 : /* Copy out parameters */
814 0 : *state->orig.out.ClusterName = *state->tmp.out.ClusterName;
815 0 : *state->orig.out.NodeName = *state->tmp.out.NodeName;
816 :
817 : /* Copy result */
818 0 : state->orig.out.result = state->tmp.out.result;
819 :
820 : /* Reset temporary structure */
821 0 : NDR_ZERO_STRUCT(state->tmp);
822 :
823 0 : tevent_req_done(req);
824 : }
825 :
826 0 : NTSTATUS dcerpc_clusapi_GetClusterName_recv(struct tevent_req *req,
827 : TALLOC_CTX *mem_ctx,
828 : WERROR *result)
829 : {
830 0 : struct dcerpc_clusapi_GetClusterName_state *state = tevent_req_data(
831 : req, struct dcerpc_clusapi_GetClusterName_state);
832 : NTSTATUS status;
833 :
834 0 : if (tevent_req_is_nterror(req, &status)) {
835 0 : tevent_req_received(req);
836 0 : return status;
837 : }
838 :
839 : /* Steal possible out parameters to the callers context */
840 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
841 :
842 : /* Return result */
843 0 : *result = state->orig.out.result;
844 :
845 0 : tevent_req_received(req);
846 0 : return NT_STATUS_OK;
847 : }
848 :
849 0 : NTSTATUS dcerpc_clusapi_GetClusterName(struct dcerpc_binding_handle *h,
850 : TALLOC_CTX *mem_ctx,
851 : const char **_ClusterName /* [out] [charset(UTF16),ref] */,
852 : const char **_NodeName /* [out] [charset(UTF16),ref] */,
853 : WERROR *result)
854 : {
855 : struct clusapi_GetClusterName r;
856 : NTSTATUS status;
857 :
858 : /* In parameters */
859 :
860 : /* Out parameters */
861 0 : r.out.ClusterName = _ClusterName;
862 0 : r.out.NodeName = _NodeName;
863 :
864 : /* Result */
865 0 : NDR_ZERO_STRUCT(r.out.result);
866 :
867 0 : status = dcerpc_clusapi_GetClusterName_r(h, mem_ctx, &r);
868 0 : if (!NT_STATUS_IS_OK(status)) {
869 0 : return status;
870 : }
871 :
872 : /* Return variables */
873 0 : *_ClusterName = *r.out.ClusterName;
874 0 : *_NodeName = *r.out.NodeName;
875 :
876 : /* Return result */
877 0 : *result = r.out.result;
878 :
879 0 : return NT_STATUS_OK;
880 : }
881 :
882 : struct dcerpc_clusapi_GetClusterVersion_r_state {
883 : TALLOC_CTX *out_mem_ctx;
884 : };
885 :
886 : static void dcerpc_clusapi_GetClusterVersion_r_done(struct tevent_req *subreq);
887 :
888 0 : struct tevent_req *dcerpc_clusapi_GetClusterVersion_r_send(TALLOC_CTX *mem_ctx,
889 : struct tevent_context *ev,
890 : struct dcerpc_binding_handle *h,
891 : struct clusapi_GetClusterVersion *r)
892 : {
893 : struct tevent_req *req;
894 : struct dcerpc_clusapi_GetClusterVersion_r_state *state;
895 : struct tevent_req *subreq;
896 :
897 0 : req = tevent_req_create(mem_ctx, &state,
898 : struct dcerpc_clusapi_GetClusterVersion_r_state);
899 0 : if (req == NULL) {
900 0 : return NULL;
901 : }
902 :
903 0 : state->out_mem_ctx = talloc_new(state);
904 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
905 0 : return tevent_req_post(req, ev);
906 : }
907 :
908 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
909 : NULL, &ndr_table_clusapi,
910 0 : NDR_CLUSAPI_GETCLUSTERVERSION, state->out_mem_ctx, r);
911 0 : if (tevent_req_nomem(subreq, req)) {
912 0 : return tevent_req_post(req, ev);
913 : }
914 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterVersion_r_done, req);
915 :
916 0 : return req;
917 : }
918 :
919 0 : static void dcerpc_clusapi_GetClusterVersion_r_done(struct tevent_req *subreq)
920 : {
921 0 : struct tevent_req *req =
922 0 : tevent_req_callback_data(subreq,
923 : struct tevent_req);
924 : NTSTATUS status;
925 :
926 0 : status = dcerpc_binding_handle_call_recv(subreq);
927 0 : TALLOC_FREE(subreq);
928 0 : if (tevent_req_nterror(req, status)) {
929 0 : return;
930 : }
931 :
932 0 : tevent_req_done(req);
933 : }
934 :
935 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
936 : {
937 0 : struct dcerpc_clusapi_GetClusterVersion_r_state *state =
938 0 : tevent_req_data(req,
939 : struct dcerpc_clusapi_GetClusterVersion_r_state);
940 : NTSTATUS status;
941 :
942 0 : if (tevent_req_is_nterror(req, &status)) {
943 0 : tevent_req_received(req);
944 0 : return status;
945 : }
946 :
947 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
948 :
949 0 : tevent_req_received(req);
950 0 : return NT_STATUS_OK;
951 : }
952 :
953 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetClusterVersion *r)
954 : {
955 : NTSTATUS status;
956 :
957 0 : status = dcerpc_binding_handle_call(h,
958 : NULL, &ndr_table_clusapi,
959 : NDR_CLUSAPI_GETCLUSTERVERSION, mem_ctx, r);
960 :
961 0 : return status;
962 : }
963 :
964 : struct dcerpc_clusapi_GetClusterVersion_state {
965 : struct clusapi_GetClusterVersion orig;
966 : struct clusapi_GetClusterVersion tmp;
967 : TALLOC_CTX *out_mem_ctx;
968 : };
969 :
970 : static void dcerpc_clusapi_GetClusterVersion_done(struct tevent_req *subreq);
971 :
972 0 : struct tevent_req *dcerpc_clusapi_GetClusterVersion_send(TALLOC_CTX *mem_ctx,
973 : struct tevent_context *ev,
974 : struct dcerpc_binding_handle *h,
975 : uint16_t *_lpwMajorVersion /* [out] [ref] */,
976 : uint16_t *_lpwMinorVersion /* [out] [ref] */,
977 : uint16_t *_lpwBuildNumber /* [out] [ref] */,
978 : const char **_lpszVendorId /* [out] [charset(UTF16),ref] */,
979 : const char **_lpszCSDVersion /* [out] [charset(UTF16),ref] */)
980 : {
981 : struct tevent_req *req;
982 : struct dcerpc_clusapi_GetClusterVersion_state *state;
983 : struct tevent_req *subreq;
984 :
985 0 : req = tevent_req_create(mem_ctx, &state,
986 : struct dcerpc_clusapi_GetClusterVersion_state);
987 0 : if (req == NULL) {
988 0 : return NULL;
989 : }
990 0 : state->out_mem_ctx = NULL;
991 :
992 : /* In parameters */
993 :
994 : /* Out parameters */
995 0 : state->orig.out.lpwMajorVersion = _lpwMajorVersion;
996 0 : state->orig.out.lpwMinorVersion = _lpwMinorVersion;
997 0 : state->orig.out.lpwBuildNumber = _lpwBuildNumber;
998 0 : state->orig.out.lpszVendorId = _lpszVendorId;
999 0 : state->orig.out.lpszCSDVersion = _lpszCSDVersion;
1000 :
1001 : /* Result */
1002 0 : NDR_ZERO_STRUCT(state->orig.out.result);
1003 :
1004 0 : state->out_mem_ctx = talloc_named_const(state, 0,
1005 : "dcerpc_clusapi_GetClusterVersion_out_memory");
1006 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1007 0 : return tevent_req_post(req, ev);
1008 : }
1009 :
1010 : /* make a temporary copy, that we pass to the dispatch function */
1011 0 : state->tmp = state->orig;
1012 :
1013 0 : subreq = dcerpc_clusapi_GetClusterVersion_r_send(state, ev, h, &state->tmp);
1014 0 : if (tevent_req_nomem(subreq, req)) {
1015 0 : return tevent_req_post(req, ev);
1016 : }
1017 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterVersion_done, req);
1018 0 : return req;
1019 : }
1020 :
1021 0 : static void dcerpc_clusapi_GetClusterVersion_done(struct tevent_req *subreq)
1022 : {
1023 0 : struct tevent_req *req = tevent_req_callback_data(
1024 : subreq, struct tevent_req);
1025 0 : struct dcerpc_clusapi_GetClusterVersion_state *state = tevent_req_data(
1026 : req, struct dcerpc_clusapi_GetClusterVersion_state);
1027 : NTSTATUS status;
1028 : TALLOC_CTX *mem_ctx;
1029 :
1030 0 : if (state->out_mem_ctx) {
1031 0 : mem_ctx = state->out_mem_ctx;
1032 : } else {
1033 0 : mem_ctx = state;
1034 : }
1035 :
1036 0 : status = dcerpc_clusapi_GetClusterVersion_r_recv(subreq, mem_ctx);
1037 0 : TALLOC_FREE(subreq);
1038 0 : if (tevent_req_nterror(req, status)) {
1039 0 : return;
1040 : }
1041 :
1042 : /* Copy out parameters */
1043 0 : *state->orig.out.lpwMajorVersion = *state->tmp.out.lpwMajorVersion;
1044 0 : *state->orig.out.lpwMinorVersion = *state->tmp.out.lpwMinorVersion;
1045 0 : *state->orig.out.lpwBuildNumber = *state->tmp.out.lpwBuildNumber;
1046 0 : *state->orig.out.lpszVendorId = *state->tmp.out.lpszVendorId;
1047 0 : *state->orig.out.lpszCSDVersion = *state->tmp.out.lpszCSDVersion;
1048 :
1049 : /* Copy result */
1050 0 : state->orig.out.result = state->tmp.out.result;
1051 :
1052 : /* Reset temporary structure */
1053 0 : NDR_ZERO_STRUCT(state->tmp);
1054 :
1055 0 : tevent_req_done(req);
1056 : }
1057 :
1058 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion_recv(struct tevent_req *req,
1059 : TALLOC_CTX *mem_ctx,
1060 : WERROR *result)
1061 : {
1062 0 : struct dcerpc_clusapi_GetClusterVersion_state *state = tevent_req_data(
1063 : req, struct dcerpc_clusapi_GetClusterVersion_state);
1064 : NTSTATUS status;
1065 :
1066 0 : if (tevent_req_is_nterror(req, &status)) {
1067 0 : tevent_req_received(req);
1068 0 : return status;
1069 : }
1070 :
1071 : /* Steal possible out parameters to the callers context */
1072 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1073 :
1074 : /* Return result */
1075 0 : *result = state->orig.out.result;
1076 :
1077 0 : tevent_req_received(req);
1078 0 : return NT_STATUS_OK;
1079 : }
1080 :
1081 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion(struct dcerpc_binding_handle *h,
1082 : TALLOC_CTX *mem_ctx,
1083 : uint16_t *_lpwMajorVersion /* [out] [ref] */,
1084 : uint16_t *_lpwMinorVersion /* [out] [ref] */,
1085 : uint16_t *_lpwBuildNumber /* [out] [ref] */,
1086 : const char **_lpszVendorId /* [out] [charset(UTF16),ref] */,
1087 : const char **_lpszCSDVersion /* [out] [charset(UTF16),ref] */,
1088 : WERROR *result)
1089 : {
1090 : struct clusapi_GetClusterVersion r;
1091 : NTSTATUS status;
1092 :
1093 : /* In parameters */
1094 :
1095 : /* Out parameters */
1096 0 : r.out.lpwMajorVersion = _lpwMajorVersion;
1097 0 : r.out.lpwMinorVersion = _lpwMinorVersion;
1098 0 : r.out.lpwBuildNumber = _lpwBuildNumber;
1099 0 : r.out.lpszVendorId = _lpszVendorId;
1100 0 : r.out.lpszCSDVersion = _lpszCSDVersion;
1101 :
1102 : /* Result */
1103 0 : NDR_ZERO_STRUCT(r.out.result);
1104 :
1105 0 : status = dcerpc_clusapi_GetClusterVersion_r(h, mem_ctx, &r);
1106 0 : if (!NT_STATUS_IS_OK(status)) {
1107 0 : return status;
1108 : }
1109 :
1110 : /* Return variables */
1111 0 : *_lpwMajorVersion = *r.out.lpwMajorVersion;
1112 0 : *_lpwMinorVersion = *r.out.lpwMinorVersion;
1113 0 : *_lpwBuildNumber = *r.out.lpwBuildNumber;
1114 0 : *_lpszVendorId = *r.out.lpszVendorId;
1115 0 : *_lpszCSDVersion = *r.out.lpszCSDVersion;
1116 :
1117 : /* Return result */
1118 0 : *result = r.out.result;
1119 :
1120 0 : return NT_STATUS_OK;
1121 : }
1122 :
1123 : struct dcerpc_clusapi_GetQuorumResource_r_state {
1124 : TALLOC_CTX *out_mem_ctx;
1125 : };
1126 :
1127 : static void dcerpc_clusapi_GetQuorumResource_r_done(struct tevent_req *subreq);
1128 :
1129 0 : struct tevent_req *dcerpc_clusapi_GetQuorumResource_r_send(TALLOC_CTX *mem_ctx,
1130 : struct tevent_context *ev,
1131 : struct dcerpc_binding_handle *h,
1132 : struct clusapi_GetQuorumResource *r)
1133 : {
1134 : struct tevent_req *req;
1135 : struct dcerpc_clusapi_GetQuorumResource_r_state *state;
1136 : struct tevent_req *subreq;
1137 :
1138 0 : req = tevent_req_create(mem_ctx, &state,
1139 : struct dcerpc_clusapi_GetQuorumResource_r_state);
1140 0 : if (req == NULL) {
1141 0 : return NULL;
1142 : }
1143 :
1144 0 : state->out_mem_ctx = talloc_new(state);
1145 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1146 0 : return tevent_req_post(req, ev);
1147 : }
1148 :
1149 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
1150 : NULL, &ndr_table_clusapi,
1151 0 : NDR_CLUSAPI_GETQUORUMRESOURCE, state->out_mem_ctx, r);
1152 0 : if (tevent_req_nomem(subreq, req)) {
1153 0 : return tevent_req_post(req, ev);
1154 : }
1155 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetQuorumResource_r_done, req);
1156 :
1157 0 : return req;
1158 : }
1159 :
1160 0 : static void dcerpc_clusapi_GetQuorumResource_r_done(struct tevent_req *subreq)
1161 : {
1162 0 : struct tevent_req *req =
1163 0 : tevent_req_callback_data(subreq,
1164 : struct tevent_req);
1165 : NTSTATUS status;
1166 :
1167 0 : status = dcerpc_binding_handle_call_recv(subreq);
1168 0 : TALLOC_FREE(subreq);
1169 0 : if (tevent_req_nterror(req, status)) {
1170 0 : return;
1171 : }
1172 :
1173 0 : tevent_req_done(req);
1174 : }
1175 :
1176 0 : NTSTATUS dcerpc_clusapi_GetQuorumResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1177 : {
1178 0 : struct dcerpc_clusapi_GetQuorumResource_r_state *state =
1179 0 : tevent_req_data(req,
1180 : struct dcerpc_clusapi_GetQuorumResource_r_state);
1181 : NTSTATUS status;
1182 :
1183 0 : if (tevent_req_is_nterror(req, &status)) {
1184 0 : tevent_req_received(req);
1185 0 : return status;
1186 : }
1187 :
1188 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1189 :
1190 0 : tevent_req_received(req);
1191 0 : return NT_STATUS_OK;
1192 : }
1193 :
1194 0 : NTSTATUS dcerpc_clusapi_GetQuorumResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetQuorumResource *r)
1195 : {
1196 : NTSTATUS status;
1197 :
1198 0 : status = dcerpc_binding_handle_call(h,
1199 : NULL, &ndr_table_clusapi,
1200 : NDR_CLUSAPI_GETQUORUMRESOURCE, mem_ctx, r);
1201 :
1202 0 : return status;
1203 : }
1204 :
1205 : struct dcerpc_clusapi_GetQuorumResource_state {
1206 : struct clusapi_GetQuorumResource orig;
1207 : struct clusapi_GetQuorumResource tmp;
1208 : TALLOC_CTX *out_mem_ctx;
1209 : };
1210 :
1211 : static void dcerpc_clusapi_GetQuorumResource_done(struct tevent_req *subreq);
1212 :
1213 0 : struct tevent_req *dcerpc_clusapi_GetQuorumResource_send(TALLOC_CTX *mem_ctx,
1214 : struct tevent_context *ev,
1215 : struct dcerpc_binding_handle *h,
1216 : const char **_lpszResourceName /* [out] [charset(UTF16),ref] */,
1217 : const char **_lpszDeviceName /* [out] [charset(UTF16),ref] */,
1218 : uint32_t *_pdwMaxQuorumLogSize /* [out] [ref] */,
1219 : WERROR *_rpc_status /* [out] [ref] */)
1220 : {
1221 : struct tevent_req *req;
1222 : struct dcerpc_clusapi_GetQuorumResource_state *state;
1223 : struct tevent_req *subreq;
1224 :
1225 0 : req = tevent_req_create(mem_ctx, &state,
1226 : struct dcerpc_clusapi_GetQuorumResource_state);
1227 0 : if (req == NULL) {
1228 0 : return NULL;
1229 : }
1230 0 : state->out_mem_ctx = NULL;
1231 :
1232 : /* In parameters */
1233 :
1234 : /* Out parameters */
1235 0 : state->orig.out.lpszResourceName = _lpszResourceName;
1236 0 : state->orig.out.lpszDeviceName = _lpszDeviceName;
1237 0 : state->orig.out.pdwMaxQuorumLogSize = _pdwMaxQuorumLogSize;
1238 0 : state->orig.out.rpc_status = _rpc_status;
1239 :
1240 : /* Result */
1241 0 : NDR_ZERO_STRUCT(state->orig.out.result);
1242 :
1243 0 : state->out_mem_ctx = talloc_named_const(state, 0,
1244 : "dcerpc_clusapi_GetQuorumResource_out_memory");
1245 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1246 0 : return tevent_req_post(req, ev);
1247 : }
1248 :
1249 : /* make a temporary copy, that we pass to the dispatch function */
1250 0 : state->tmp = state->orig;
1251 :
1252 0 : subreq = dcerpc_clusapi_GetQuorumResource_r_send(state, ev, h, &state->tmp);
1253 0 : if (tevent_req_nomem(subreq, req)) {
1254 0 : return tevent_req_post(req, ev);
1255 : }
1256 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetQuorumResource_done, req);
1257 0 : return req;
1258 : }
1259 :
1260 0 : static void dcerpc_clusapi_GetQuorumResource_done(struct tevent_req *subreq)
1261 : {
1262 0 : struct tevent_req *req = tevent_req_callback_data(
1263 : subreq, struct tevent_req);
1264 0 : struct dcerpc_clusapi_GetQuorumResource_state *state = tevent_req_data(
1265 : req, struct dcerpc_clusapi_GetQuorumResource_state);
1266 : NTSTATUS status;
1267 : TALLOC_CTX *mem_ctx;
1268 :
1269 0 : if (state->out_mem_ctx) {
1270 0 : mem_ctx = state->out_mem_ctx;
1271 : } else {
1272 0 : mem_ctx = state;
1273 : }
1274 :
1275 0 : status = dcerpc_clusapi_GetQuorumResource_r_recv(subreq, mem_ctx);
1276 0 : TALLOC_FREE(subreq);
1277 0 : if (tevent_req_nterror(req, status)) {
1278 0 : return;
1279 : }
1280 :
1281 : /* Copy out parameters */
1282 0 : *state->orig.out.lpszResourceName = *state->tmp.out.lpszResourceName;
1283 0 : *state->orig.out.lpszDeviceName = *state->tmp.out.lpszDeviceName;
1284 0 : *state->orig.out.pdwMaxQuorumLogSize = *state->tmp.out.pdwMaxQuorumLogSize;
1285 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
1286 :
1287 : /* Copy result */
1288 0 : state->orig.out.result = state->tmp.out.result;
1289 :
1290 : /* Reset temporary structure */
1291 0 : NDR_ZERO_STRUCT(state->tmp);
1292 :
1293 0 : tevent_req_done(req);
1294 : }
1295 :
1296 0 : NTSTATUS dcerpc_clusapi_GetQuorumResource_recv(struct tevent_req *req,
1297 : TALLOC_CTX *mem_ctx,
1298 : WERROR *result)
1299 : {
1300 0 : struct dcerpc_clusapi_GetQuorumResource_state *state = tevent_req_data(
1301 : req, struct dcerpc_clusapi_GetQuorumResource_state);
1302 : NTSTATUS status;
1303 :
1304 0 : if (tevent_req_is_nterror(req, &status)) {
1305 0 : tevent_req_received(req);
1306 0 : return status;
1307 : }
1308 :
1309 : /* Steal possible out parameters to the callers context */
1310 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1311 :
1312 : /* Return result */
1313 0 : *result = state->orig.out.result;
1314 :
1315 0 : tevent_req_received(req);
1316 0 : return NT_STATUS_OK;
1317 : }
1318 :
1319 0 : NTSTATUS dcerpc_clusapi_GetQuorumResource(struct dcerpc_binding_handle *h,
1320 : TALLOC_CTX *mem_ctx,
1321 : const char **_lpszResourceName /* [out] [charset(UTF16),ref] */,
1322 : const char **_lpszDeviceName /* [out] [charset(UTF16),ref] */,
1323 : uint32_t *_pdwMaxQuorumLogSize /* [out] [ref] */,
1324 : WERROR *_rpc_status /* [out] [ref] */,
1325 : WERROR *result)
1326 : {
1327 : struct clusapi_GetQuorumResource r;
1328 : NTSTATUS status;
1329 :
1330 : /* In parameters */
1331 :
1332 : /* Out parameters */
1333 0 : r.out.lpszResourceName = _lpszResourceName;
1334 0 : r.out.lpszDeviceName = _lpszDeviceName;
1335 0 : r.out.pdwMaxQuorumLogSize = _pdwMaxQuorumLogSize;
1336 0 : r.out.rpc_status = _rpc_status;
1337 :
1338 : /* Result */
1339 0 : NDR_ZERO_STRUCT(r.out.result);
1340 :
1341 0 : status = dcerpc_clusapi_GetQuorumResource_r(h, mem_ctx, &r);
1342 0 : if (!NT_STATUS_IS_OK(status)) {
1343 0 : return status;
1344 : }
1345 :
1346 : /* Return variables */
1347 0 : *_lpszResourceName = *r.out.lpszResourceName;
1348 0 : *_lpszDeviceName = *r.out.lpszDeviceName;
1349 0 : *_pdwMaxQuorumLogSize = *r.out.pdwMaxQuorumLogSize;
1350 0 : *_rpc_status = *r.out.rpc_status;
1351 :
1352 : /* Return result */
1353 0 : *result = r.out.result;
1354 :
1355 0 : return NT_STATUS_OK;
1356 : }
1357 :
1358 : struct dcerpc_clusapi_SetQuorumResource_r_state {
1359 : TALLOC_CTX *out_mem_ctx;
1360 : };
1361 :
1362 : static void dcerpc_clusapi_SetQuorumResource_r_done(struct tevent_req *subreq);
1363 :
1364 0 : struct tevent_req *dcerpc_clusapi_SetQuorumResource_r_send(TALLOC_CTX *mem_ctx,
1365 : struct tevent_context *ev,
1366 : struct dcerpc_binding_handle *h,
1367 : struct clusapi_SetQuorumResource *r)
1368 : {
1369 : struct tevent_req *req;
1370 : struct dcerpc_clusapi_SetQuorumResource_r_state *state;
1371 : struct tevent_req *subreq;
1372 :
1373 0 : req = tevent_req_create(mem_ctx, &state,
1374 : struct dcerpc_clusapi_SetQuorumResource_r_state);
1375 0 : if (req == NULL) {
1376 0 : return NULL;
1377 : }
1378 :
1379 0 : state->out_mem_ctx = talloc_new(state);
1380 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1381 0 : return tevent_req_post(req, ev);
1382 : }
1383 :
1384 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
1385 : NULL, &ndr_table_clusapi,
1386 0 : NDR_CLUSAPI_SETQUORUMRESOURCE, state->out_mem_ctx, r);
1387 0 : if (tevent_req_nomem(subreq, req)) {
1388 0 : return tevent_req_post(req, ev);
1389 : }
1390 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetQuorumResource_r_done, req);
1391 :
1392 0 : return req;
1393 : }
1394 :
1395 0 : static void dcerpc_clusapi_SetQuorumResource_r_done(struct tevent_req *subreq)
1396 : {
1397 0 : struct tevent_req *req =
1398 0 : tevent_req_callback_data(subreq,
1399 : struct tevent_req);
1400 : NTSTATUS status;
1401 :
1402 0 : status = dcerpc_binding_handle_call_recv(subreq);
1403 0 : TALLOC_FREE(subreq);
1404 0 : if (tevent_req_nterror(req, status)) {
1405 0 : return;
1406 : }
1407 :
1408 0 : tevent_req_done(req);
1409 : }
1410 :
1411 0 : NTSTATUS dcerpc_clusapi_SetQuorumResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1412 : {
1413 0 : struct dcerpc_clusapi_SetQuorumResource_r_state *state =
1414 0 : tevent_req_data(req,
1415 : struct dcerpc_clusapi_SetQuorumResource_r_state);
1416 : NTSTATUS status;
1417 :
1418 0 : if (tevent_req_is_nterror(req, &status)) {
1419 0 : tevent_req_received(req);
1420 0 : return status;
1421 : }
1422 :
1423 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1424 :
1425 0 : tevent_req_received(req);
1426 0 : return NT_STATUS_OK;
1427 : }
1428 :
1429 0 : NTSTATUS dcerpc_clusapi_SetQuorumResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetQuorumResource *r)
1430 : {
1431 : NTSTATUS status;
1432 :
1433 0 : status = dcerpc_binding_handle_call(h,
1434 : NULL, &ndr_table_clusapi,
1435 : NDR_CLUSAPI_SETQUORUMRESOURCE, mem_ctx, r);
1436 :
1437 0 : return status;
1438 : }
1439 :
1440 : struct dcerpc_clusapi_SetQuorumResource_state {
1441 : struct clusapi_SetQuorumResource orig;
1442 : struct clusapi_SetQuorumResource tmp;
1443 : TALLOC_CTX *out_mem_ctx;
1444 : };
1445 :
1446 : static void dcerpc_clusapi_SetQuorumResource_done(struct tevent_req *subreq);
1447 :
1448 0 : struct tevent_req *dcerpc_clusapi_SetQuorumResource_send(TALLOC_CTX *mem_ctx,
1449 : struct tevent_context *ev,
1450 : struct dcerpc_binding_handle *h,
1451 : struct policy_handle _hResource /* [in] */,
1452 : const char *_lpszDeviceName /* [in] [charset(UTF16),ref] */,
1453 : uint32_t _dwMaxQuorumLogSize /* [in] */,
1454 : WERROR *_rpc_status /* [out] [ref] */)
1455 : {
1456 : struct tevent_req *req;
1457 : struct dcerpc_clusapi_SetQuorumResource_state *state;
1458 : struct tevent_req *subreq;
1459 :
1460 0 : req = tevent_req_create(mem_ctx, &state,
1461 : struct dcerpc_clusapi_SetQuorumResource_state);
1462 0 : if (req == NULL) {
1463 0 : return NULL;
1464 : }
1465 0 : state->out_mem_ctx = NULL;
1466 :
1467 : /* In parameters */
1468 0 : state->orig.in.hResource = _hResource;
1469 0 : state->orig.in.lpszDeviceName = _lpszDeviceName;
1470 0 : state->orig.in.dwMaxQuorumLogSize = _dwMaxQuorumLogSize;
1471 :
1472 : /* Out parameters */
1473 0 : state->orig.out.rpc_status = _rpc_status;
1474 :
1475 : /* Result */
1476 0 : NDR_ZERO_STRUCT(state->orig.out.result);
1477 :
1478 0 : state->out_mem_ctx = talloc_named_const(state, 0,
1479 : "dcerpc_clusapi_SetQuorumResource_out_memory");
1480 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1481 0 : return tevent_req_post(req, ev);
1482 : }
1483 :
1484 : /* make a temporary copy, that we pass to the dispatch function */
1485 0 : state->tmp = state->orig;
1486 :
1487 0 : subreq = dcerpc_clusapi_SetQuorumResource_r_send(state, ev, h, &state->tmp);
1488 0 : if (tevent_req_nomem(subreq, req)) {
1489 0 : return tevent_req_post(req, ev);
1490 : }
1491 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetQuorumResource_done, req);
1492 0 : return req;
1493 : }
1494 :
1495 0 : static void dcerpc_clusapi_SetQuorumResource_done(struct tevent_req *subreq)
1496 : {
1497 0 : struct tevent_req *req = tevent_req_callback_data(
1498 : subreq, struct tevent_req);
1499 0 : struct dcerpc_clusapi_SetQuorumResource_state *state = tevent_req_data(
1500 : req, struct dcerpc_clusapi_SetQuorumResource_state);
1501 : NTSTATUS status;
1502 : TALLOC_CTX *mem_ctx;
1503 :
1504 0 : if (state->out_mem_ctx) {
1505 0 : mem_ctx = state->out_mem_ctx;
1506 : } else {
1507 0 : mem_ctx = state;
1508 : }
1509 :
1510 0 : status = dcerpc_clusapi_SetQuorumResource_r_recv(subreq, mem_ctx);
1511 0 : TALLOC_FREE(subreq);
1512 0 : if (tevent_req_nterror(req, status)) {
1513 0 : return;
1514 : }
1515 :
1516 : /* Copy out parameters */
1517 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
1518 :
1519 : /* Copy result */
1520 0 : state->orig.out.result = state->tmp.out.result;
1521 :
1522 : /* Reset temporary structure */
1523 0 : NDR_ZERO_STRUCT(state->tmp);
1524 :
1525 0 : tevent_req_done(req);
1526 : }
1527 :
1528 0 : NTSTATUS dcerpc_clusapi_SetQuorumResource_recv(struct tevent_req *req,
1529 : TALLOC_CTX *mem_ctx,
1530 : WERROR *result)
1531 : {
1532 0 : struct dcerpc_clusapi_SetQuorumResource_state *state = tevent_req_data(
1533 : req, struct dcerpc_clusapi_SetQuorumResource_state);
1534 : NTSTATUS status;
1535 :
1536 0 : if (tevent_req_is_nterror(req, &status)) {
1537 0 : tevent_req_received(req);
1538 0 : return status;
1539 : }
1540 :
1541 : /* Steal possible out parameters to the callers context */
1542 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1543 :
1544 : /* Return result */
1545 0 : *result = state->orig.out.result;
1546 :
1547 0 : tevent_req_received(req);
1548 0 : return NT_STATUS_OK;
1549 : }
1550 :
1551 0 : NTSTATUS dcerpc_clusapi_SetQuorumResource(struct dcerpc_binding_handle *h,
1552 : TALLOC_CTX *mem_ctx,
1553 : struct policy_handle _hResource /* [in] */,
1554 : const char *_lpszDeviceName /* [in] [charset(UTF16),ref] */,
1555 : uint32_t _dwMaxQuorumLogSize /* [in] */,
1556 : WERROR *_rpc_status /* [out] [ref] */,
1557 : WERROR *result)
1558 : {
1559 : struct clusapi_SetQuorumResource r;
1560 : NTSTATUS status;
1561 :
1562 : /* In parameters */
1563 0 : r.in.hResource = _hResource;
1564 0 : r.in.lpszDeviceName = _lpszDeviceName;
1565 0 : r.in.dwMaxQuorumLogSize = _dwMaxQuorumLogSize;
1566 :
1567 : /* Out parameters */
1568 0 : r.out.rpc_status = _rpc_status;
1569 :
1570 : /* Result */
1571 0 : NDR_ZERO_STRUCT(r.out.result);
1572 :
1573 0 : status = dcerpc_clusapi_SetQuorumResource_r(h, mem_ctx, &r);
1574 0 : if (!NT_STATUS_IS_OK(status)) {
1575 0 : return status;
1576 : }
1577 :
1578 : /* Return variables */
1579 0 : *_rpc_status = *r.out.rpc_status;
1580 :
1581 : /* Return result */
1582 0 : *result = r.out.result;
1583 :
1584 0 : return NT_STATUS_OK;
1585 : }
1586 :
1587 : struct dcerpc_clusapi_CreateEnum_r_state {
1588 : TALLOC_CTX *out_mem_ctx;
1589 : };
1590 :
1591 : static void dcerpc_clusapi_CreateEnum_r_done(struct tevent_req *subreq);
1592 :
1593 0 : struct tevent_req *dcerpc_clusapi_CreateEnum_r_send(TALLOC_CTX *mem_ctx,
1594 : struct tevent_context *ev,
1595 : struct dcerpc_binding_handle *h,
1596 : struct clusapi_CreateEnum *r)
1597 : {
1598 : struct tevent_req *req;
1599 : struct dcerpc_clusapi_CreateEnum_r_state *state;
1600 : struct tevent_req *subreq;
1601 :
1602 0 : req = tevent_req_create(mem_ctx, &state,
1603 : struct dcerpc_clusapi_CreateEnum_r_state);
1604 0 : if (req == NULL) {
1605 0 : return NULL;
1606 : }
1607 :
1608 0 : state->out_mem_ctx = talloc_new(state);
1609 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1610 0 : return tevent_req_post(req, ev);
1611 : }
1612 :
1613 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
1614 : NULL, &ndr_table_clusapi,
1615 0 : NDR_CLUSAPI_CREATEENUM, state->out_mem_ctx, r);
1616 0 : if (tevent_req_nomem(subreq, req)) {
1617 0 : return tevent_req_post(req, ev);
1618 : }
1619 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateEnum_r_done, req);
1620 :
1621 0 : return req;
1622 : }
1623 :
1624 0 : static void dcerpc_clusapi_CreateEnum_r_done(struct tevent_req *subreq)
1625 : {
1626 0 : struct tevent_req *req =
1627 0 : tevent_req_callback_data(subreq,
1628 : struct tevent_req);
1629 : NTSTATUS status;
1630 :
1631 0 : status = dcerpc_binding_handle_call_recv(subreq);
1632 0 : TALLOC_FREE(subreq);
1633 0 : if (tevent_req_nterror(req, status)) {
1634 0 : return;
1635 : }
1636 :
1637 0 : tevent_req_done(req);
1638 : }
1639 :
1640 0 : NTSTATUS dcerpc_clusapi_CreateEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1641 : {
1642 0 : struct dcerpc_clusapi_CreateEnum_r_state *state =
1643 0 : tevent_req_data(req,
1644 : struct dcerpc_clusapi_CreateEnum_r_state);
1645 : NTSTATUS status;
1646 :
1647 0 : if (tevent_req_is_nterror(req, &status)) {
1648 0 : tevent_req_received(req);
1649 0 : return status;
1650 : }
1651 :
1652 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1653 :
1654 0 : tevent_req_received(req);
1655 0 : return NT_STATUS_OK;
1656 : }
1657 :
1658 0 : NTSTATUS dcerpc_clusapi_CreateEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateEnum *r)
1659 : {
1660 : NTSTATUS status;
1661 :
1662 0 : status = dcerpc_binding_handle_call(h,
1663 : NULL, &ndr_table_clusapi,
1664 : NDR_CLUSAPI_CREATEENUM, mem_ctx, r);
1665 :
1666 0 : return status;
1667 : }
1668 :
1669 : struct dcerpc_clusapi_CreateEnum_state {
1670 : struct clusapi_CreateEnum orig;
1671 : struct clusapi_CreateEnum tmp;
1672 : TALLOC_CTX *out_mem_ctx;
1673 : };
1674 :
1675 : static void dcerpc_clusapi_CreateEnum_done(struct tevent_req *subreq);
1676 :
1677 0 : struct tevent_req *dcerpc_clusapi_CreateEnum_send(TALLOC_CTX *mem_ctx,
1678 : struct tevent_context *ev,
1679 : struct dcerpc_binding_handle *h,
1680 : uint32_t _dwType /* [in] */,
1681 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
1682 : WERROR *_rpc_status /* [out] [ref] */)
1683 : {
1684 : struct tevent_req *req;
1685 : struct dcerpc_clusapi_CreateEnum_state *state;
1686 : struct tevent_req *subreq;
1687 :
1688 0 : req = tevent_req_create(mem_ctx, &state,
1689 : struct dcerpc_clusapi_CreateEnum_state);
1690 0 : if (req == NULL) {
1691 0 : return NULL;
1692 : }
1693 0 : state->out_mem_ctx = NULL;
1694 :
1695 : /* In parameters */
1696 0 : state->orig.in.dwType = _dwType;
1697 :
1698 : /* Out parameters */
1699 0 : state->orig.out.ReturnEnum = _ReturnEnum;
1700 0 : state->orig.out.rpc_status = _rpc_status;
1701 :
1702 : /* Result */
1703 0 : NDR_ZERO_STRUCT(state->orig.out.result);
1704 :
1705 0 : state->out_mem_ctx = talloc_named_const(state, 0,
1706 : "dcerpc_clusapi_CreateEnum_out_memory");
1707 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1708 0 : return tevent_req_post(req, ev);
1709 : }
1710 :
1711 : /* make a temporary copy, that we pass to the dispatch function */
1712 0 : state->tmp = state->orig;
1713 :
1714 0 : subreq = dcerpc_clusapi_CreateEnum_r_send(state, ev, h, &state->tmp);
1715 0 : if (tevent_req_nomem(subreq, req)) {
1716 0 : return tevent_req_post(req, ev);
1717 : }
1718 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateEnum_done, req);
1719 0 : return req;
1720 : }
1721 :
1722 0 : static void dcerpc_clusapi_CreateEnum_done(struct tevent_req *subreq)
1723 : {
1724 0 : struct tevent_req *req = tevent_req_callback_data(
1725 : subreq, struct tevent_req);
1726 0 : struct dcerpc_clusapi_CreateEnum_state *state = tevent_req_data(
1727 : req, struct dcerpc_clusapi_CreateEnum_state);
1728 : NTSTATUS status;
1729 : TALLOC_CTX *mem_ctx;
1730 :
1731 0 : if (state->out_mem_ctx) {
1732 0 : mem_ctx = state->out_mem_ctx;
1733 : } else {
1734 0 : mem_ctx = state;
1735 : }
1736 :
1737 0 : status = dcerpc_clusapi_CreateEnum_r_recv(subreq, mem_ctx);
1738 0 : TALLOC_FREE(subreq);
1739 0 : if (tevent_req_nterror(req, status)) {
1740 0 : return;
1741 : }
1742 :
1743 : /* Copy out parameters */
1744 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
1745 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
1746 :
1747 : /* Copy result */
1748 0 : state->orig.out.result = state->tmp.out.result;
1749 :
1750 : /* Reset temporary structure */
1751 0 : NDR_ZERO_STRUCT(state->tmp);
1752 :
1753 0 : tevent_req_done(req);
1754 : }
1755 :
1756 0 : NTSTATUS dcerpc_clusapi_CreateEnum_recv(struct tevent_req *req,
1757 : TALLOC_CTX *mem_ctx,
1758 : WERROR *result)
1759 : {
1760 0 : struct dcerpc_clusapi_CreateEnum_state *state = tevent_req_data(
1761 : req, struct dcerpc_clusapi_CreateEnum_state);
1762 : NTSTATUS status;
1763 :
1764 0 : if (tevent_req_is_nterror(req, &status)) {
1765 0 : tevent_req_received(req);
1766 0 : return status;
1767 : }
1768 :
1769 : /* Steal possible out parameters to the callers context */
1770 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1771 :
1772 : /* Return result */
1773 0 : *result = state->orig.out.result;
1774 :
1775 0 : tevent_req_received(req);
1776 0 : return NT_STATUS_OK;
1777 : }
1778 :
1779 0 : NTSTATUS dcerpc_clusapi_CreateEnum(struct dcerpc_binding_handle *h,
1780 : TALLOC_CTX *mem_ctx,
1781 : uint32_t _dwType /* [in] */,
1782 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
1783 : WERROR *_rpc_status /* [out] [ref] */,
1784 : WERROR *result)
1785 : {
1786 : struct clusapi_CreateEnum r;
1787 : NTSTATUS status;
1788 :
1789 : /* In parameters */
1790 0 : r.in.dwType = _dwType;
1791 :
1792 : /* Out parameters */
1793 0 : r.out.ReturnEnum = _ReturnEnum;
1794 0 : r.out.rpc_status = _rpc_status;
1795 :
1796 : /* Result */
1797 0 : NDR_ZERO_STRUCT(r.out.result);
1798 :
1799 0 : status = dcerpc_clusapi_CreateEnum_r(h, mem_ctx, &r);
1800 0 : if (!NT_STATUS_IS_OK(status)) {
1801 0 : return status;
1802 : }
1803 :
1804 : /* Return variables */
1805 0 : *_ReturnEnum = *r.out.ReturnEnum;
1806 0 : *_rpc_status = *r.out.rpc_status;
1807 :
1808 : /* Return result */
1809 0 : *result = r.out.result;
1810 :
1811 0 : return NT_STATUS_OK;
1812 : }
1813 :
1814 : struct dcerpc_clusapi_OpenResource_r_state {
1815 : TALLOC_CTX *out_mem_ctx;
1816 : };
1817 :
1818 : static void dcerpc_clusapi_OpenResource_r_done(struct tevent_req *subreq);
1819 :
1820 0 : struct tevent_req *dcerpc_clusapi_OpenResource_r_send(TALLOC_CTX *mem_ctx,
1821 : struct tevent_context *ev,
1822 : struct dcerpc_binding_handle *h,
1823 : struct clusapi_OpenResource *r)
1824 : {
1825 : struct tevent_req *req;
1826 : struct dcerpc_clusapi_OpenResource_r_state *state;
1827 : struct tevent_req *subreq;
1828 :
1829 0 : req = tevent_req_create(mem_ctx, &state,
1830 : struct dcerpc_clusapi_OpenResource_r_state);
1831 0 : if (req == NULL) {
1832 0 : return NULL;
1833 : }
1834 :
1835 0 : state->out_mem_ctx = talloc_new(state);
1836 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1837 0 : return tevent_req_post(req, ev);
1838 : }
1839 :
1840 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
1841 : NULL, &ndr_table_clusapi,
1842 0 : NDR_CLUSAPI_OPENRESOURCE, state->out_mem_ctx, r);
1843 0 : if (tevent_req_nomem(subreq, req)) {
1844 0 : return tevent_req_post(req, ev);
1845 : }
1846 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenResource_r_done, req);
1847 :
1848 0 : return req;
1849 : }
1850 :
1851 0 : static void dcerpc_clusapi_OpenResource_r_done(struct tevent_req *subreq)
1852 : {
1853 0 : struct tevent_req *req =
1854 0 : tevent_req_callback_data(subreq,
1855 : struct tevent_req);
1856 : NTSTATUS status;
1857 :
1858 0 : status = dcerpc_binding_handle_call_recv(subreq);
1859 0 : TALLOC_FREE(subreq);
1860 0 : if (tevent_req_nterror(req, status)) {
1861 0 : return;
1862 : }
1863 :
1864 0 : tevent_req_done(req);
1865 : }
1866 :
1867 0 : NTSTATUS dcerpc_clusapi_OpenResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1868 : {
1869 0 : struct dcerpc_clusapi_OpenResource_r_state *state =
1870 0 : tevent_req_data(req,
1871 : struct dcerpc_clusapi_OpenResource_r_state);
1872 : NTSTATUS status;
1873 :
1874 0 : if (tevent_req_is_nterror(req, &status)) {
1875 0 : tevent_req_received(req);
1876 0 : return status;
1877 : }
1878 :
1879 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1880 :
1881 0 : tevent_req_received(req);
1882 0 : return NT_STATUS_OK;
1883 : }
1884 :
1885 0 : NTSTATUS dcerpc_clusapi_OpenResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenResource *r)
1886 : {
1887 : NTSTATUS status;
1888 :
1889 0 : status = dcerpc_binding_handle_call(h,
1890 : NULL, &ndr_table_clusapi,
1891 : NDR_CLUSAPI_OPENRESOURCE, mem_ctx, r);
1892 :
1893 0 : return status;
1894 : }
1895 :
1896 : struct dcerpc_clusapi_OpenResource_state {
1897 : struct clusapi_OpenResource orig;
1898 : struct clusapi_OpenResource tmp;
1899 : TALLOC_CTX *out_mem_ctx;
1900 : };
1901 :
1902 : static void dcerpc_clusapi_OpenResource_done(struct tevent_req *subreq);
1903 :
1904 0 : struct tevent_req *dcerpc_clusapi_OpenResource_send(TALLOC_CTX *mem_ctx,
1905 : struct tevent_context *ev,
1906 : struct dcerpc_binding_handle *h,
1907 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
1908 : WERROR *_Status /* [out] [ref] */,
1909 : WERROR *_rpc_status /* [out] [ref] */,
1910 : struct policy_handle *_hResource /* [out] [ref] */)
1911 : {
1912 : struct tevent_req *req;
1913 : struct dcerpc_clusapi_OpenResource_state *state;
1914 : struct tevent_req *subreq;
1915 :
1916 0 : req = tevent_req_create(mem_ctx, &state,
1917 : struct dcerpc_clusapi_OpenResource_state);
1918 0 : if (req == NULL) {
1919 0 : return NULL;
1920 : }
1921 0 : state->out_mem_ctx = NULL;
1922 :
1923 : /* In parameters */
1924 0 : state->orig.in.lpszResourceName = _lpszResourceName;
1925 :
1926 : /* Out parameters */
1927 0 : state->orig.out.Status = _Status;
1928 0 : state->orig.out.rpc_status = _rpc_status;
1929 0 : state->orig.out.hResource = _hResource;
1930 :
1931 0 : state->out_mem_ctx = talloc_named_const(state, 0,
1932 : "dcerpc_clusapi_OpenResource_out_memory");
1933 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
1934 0 : return tevent_req_post(req, ev);
1935 : }
1936 :
1937 : /* make a temporary copy, that we pass to the dispatch function */
1938 0 : state->tmp = state->orig;
1939 :
1940 0 : subreq = dcerpc_clusapi_OpenResource_r_send(state, ev, h, &state->tmp);
1941 0 : if (tevent_req_nomem(subreq, req)) {
1942 0 : return tevent_req_post(req, ev);
1943 : }
1944 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenResource_done, req);
1945 0 : return req;
1946 : }
1947 :
1948 0 : static void dcerpc_clusapi_OpenResource_done(struct tevent_req *subreq)
1949 : {
1950 0 : struct tevent_req *req = tevent_req_callback_data(
1951 : subreq, struct tevent_req);
1952 0 : struct dcerpc_clusapi_OpenResource_state *state = tevent_req_data(
1953 : req, struct dcerpc_clusapi_OpenResource_state);
1954 : NTSTATUS status;
1955 : TALLOC_CTX *mem_ctx;
1956 :
1957 0 : if (state->out_mem_ctx) {
1958 0 : mem_ctx = state->out_mem_ctx;
1959 : } else {
1960 0 : mem_ctx = state;
1961 : }
1962 :
1963 0 : status = dcerpc_clusapi_OpenResource_r_recv(subreq, mem_ctx);
1964 0 : TALLOC_FREE(subreq);
1965 0 : if (tevent_req_nterror(req, status)) {
1966 0 : return;
1967 : }
1968 :
1969 : /* Copy out parameters */
1970 0 : *state->orig.out.Status = *state->tmp.out.Status;
1971 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
1972 0 : *state->orig.out.hResource = *state->tmp.out.hResource;
1973 :
1974 : /* Reset temporary structure */
1975 0 : NDR_ZERO_STRUCT(state->tmp);
1976 :
1977 0 : tevent_req_done(req);
1978 : }
1979 :
1980 0 : NTSTATUS dcerpc_clusapi_OpenResource_recv(struct tevent_req *req,
1981 : TALLOC_CTX *mem_ctx)
1982 : {
1983 0 : struct dcerpc_clusapi_OpenResource_state *state = tevent_req_data(
1984 : req, struct dcerpc_clusapi_OpenResource_state);
1985 : NTSTATUS status;
1986 :
1987 0 : if (tevent_req_is_nterror(req, &status)) {
1988 0 : tevent_req_received(req);
1989 0 : return status;
1990 : }
1991 :
1992 : /* Steal possible out parameters to the callers context */
1993 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
1994 :
1995 0 : tevent_req_received(req);
1996 0 : return NT_STATUS_OK;
1997 : }
1998 :
1999 0 : NTSTATUS dcerpc_clusapi_OpenResource(struct dcerpc_binding_handle *h,
2000 : TALLOC_CTX *mem_ctx,
2001 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
2002 : WERROR *_Status /* [out] [ref] */,
2003 : WERROR *_rpc_status /* [out] [ref] */,
2004 : struct policy_handle *_hResource /* [out] [ref] */)
2005 : {
2006 : struct clusapi_OpenResource r;
2007 : NTSTATUS status;
2008 :
2009 : /* In parameters */
2010 0 : r.in.lpszResourceName = _lpszResourceName;
2011 :
2012 : /* Out parameters */
2013 0 : r.out.Status = _Status;
2014 0 : r.out.rpc_status = _rpc_status;
2015 0 : r.out.hResource = _hResource;
2016 :
2017 0 : status = dcerpc_clusapi_OpenResource_r(h, mem_ctx, &r);
2018 0 : if (!NT_STATUS_IS_OK(status)) {
2019 0 : return status;
2020 : }
2021 :
2022 : /* Return variables */
2023 0 : *_Status = *r.out.Status;
2024 0 : *_rpc_status = *r.out.rpc_status;
2025 0 : *_hResource = *r.out.hResource;
2026 :
2027 : /* Return result */
2028 :
2029 0 : return NT_STATUS_OK;
2030 : }
2031 :
2032 : struct dcerpc_clusapi_CreateResource_r_state {
2033 : TALLOC_CTX *out_mem_ctx;
2034 : };
2035 :
2036 : static void dcerpc_clusapi_CreateResource_r_done(struct tevent_req *subreq);
2037 :
2038 0 : struct tevent_req *dcerpc_clusapi_CreateResource_r_send(TALLOC_CTX *mem_ctx,
2039 : struct tevent_context *ev,
2040 : struct dcerpc_binding_handle *h,
2041 : struct clusapi_CreateResource *r)
2042 : {
2043 : struct tevent_req *req;
2044 : struct dcerpc_clusapi_CreateResource_r_state *state;
2045 : struct tevent_req *subreq;
2046 :
2047 0 : req = tevent_req_create(mem_ctx, &state,
2048 : struct dcerpc_clusapi_CreateResource_r_state);
2049 0 : if (req == NULL) {
2050 0 : return NULL;
2051 : }
2052 :
2053 0 : state->out_mem_ctx = talloc_new(state);
2054 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2055 0 : return tevent_req_post(req, ev);
2056 : }
2057 :
2058 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
2059 : NULL, &ndr_table_clusapi,
2060 0 : NDR_CLUSAPI_CREATERESOURCE, state->out_mem_ctx, r);
2061 0 : if (tevent_req_nomem(subreq, req)) {
2062 0 : return tevent_req_post(req, ev);
2063 : }
2064 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResource_r_done, req);
2065 :
2066 0 : return req;
2067 : }
2068 :
2069 0 : static void dcerpc_clusapi_CreateResource_r_done(struct tevent_req *subreq)
2070 : {
2071 0 : struct tevent_req *req =
2072 0 : tevent_req_callback_data(subreq,
2073 : struct tevent_req);
2074 : NTSTATUS status;
2075 :
2076 0 : status = dcerpc_binding_handle_call_recv(subreq);
2077 0 : TALLOC_FREE(subreq);
2078 0 : if (tevent_req_nterror(req, status)) {
2079 0 : return;
2080 : }
2081 :
2082 0 : tevent_req_done(req);
2083 : }
2084 :
2085 0 : NTSTATUS dcerpc_clusapi_CreateResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2086 : {
2087 0 : struct dcerpc_clusapi_CreateResource_r_state *state =
2088 0 : tevent_req_data(req,
2089 : struct dcerpc_clusapi_CreateResource_r_state);
2090 : NTSTATUS status;
2091 :
2092 0 : if (tevent_req_is_nterror(req, &status)) {
2093 0 : tevent_req_received(req);
2094 0 : return status;
2095 : }
2096 :
2097 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2098 :
2099 0 : tevent_req_received(req);
2100 0 : return NT_STATUS_OK;
2101 : }
2102 :
2103 0 : NTSTATUS dcerpc_clusapi_CreateResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateResource *r)
2104 : {
2105 : NTSTATUS status;
2106 :
2107 0 : status = dcerpc_binding_handle_call(h,
2108 : NULL, &ndr_table_clusapi,
2109 : NDR_CLUSAPI_CREATERESOURCE, mem_ctx, r);
2110 :
2111 0 : return status;
2112 : }
2113 :
2114 : struct dcerpc_clusapi_CreateResource_state {
2115 : struct clusapi_CreateResource orig;
2116 : struct clusapi_CreateResource tmp;
2117 : TALLOC_CTX *out_mem_ctx;
2118 : };
2119 :
2120 : static void dcerpc_clusapi_CreateResource_done(struct tevent_req *subreq);
2121 :
2122 0 : struct tevent_req *dcerpc_clusapi_CreateResource_send(TALLOC_CTX *mem_ctx,
2123 : struct tevent_context *ev,
2124 : struct dcerpc_binding_handle *h,
2125 : struct policy_handle _hGroup /* [in] */,
2126 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
2127 : const char *_lpszResourceType /* [in] [charset(UTF16),ref] */,
2128 : enum clusapi_CreateResourceFlags _dwFlags /* [in] */,
2129 : WERROR *_Status /* [out] [ref] */,
2130 : WERROR *_rpc_status /* [out] [ref] */,
2131 : struct policy_handle *_hResource /* [out] [ref] */)
2132 : {
2133 : struct tevent_req *req;
2134 : struct dcerpc_clusapi_CreateResource_state *state;
2135 : struct tevent_req *subreq;
2136 :
2137 0 : req = tevent_req_create(mem_ctx, &state,
2138 : struct dcerpc_clusapi_CreateResource_state);
2139 0 : if (req == NULL) {
2140 0 : return NULL;
2141 : }
2142 0 : state->out_mem_ctx = NULL;
2143 :
2144 : /* In parameters */
2145 0 : state->orig.in.hGroup = _hGroup;
2146 0 : state->orig.in.lpszResourceName = _lpszResourceName;
2147 0 : state->orig.in.lpszResourceType = _lpszResourceType;
2148 0 : state->orig.in.dwFlags = _dwFlags;
2149 :
2150 : /* Out parameters */
2151 0 : state->orig.out.Status = _Status;
2152 0 : state->orig.out.rpc_status = _rpc_status;
2153 0 : state->orig.out.hResource = _hResource;
2154 :
2155 0 : state->out_mem_ctx = talloc_named_const(state, 0,
2156 : "dcerpc_clusapi_CreateResource_out_memory");
2157 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2158 0 : return tevent_req_post(req, ev);
2159 : }
2160 :
2161 : /* make a temporary copy, that we pass to the dispatch function */
2162 0 : state->tmp = state->orig;
2163 :
2164 0 : subreq = dcerpc_clusapi_CreateResource_r_send(state, ev, h, &state->tmp);
2165 0 : if (tevent_req_nomem(subreq, req)) {
2166 0 : return tevent_req_post(req, ev);
2167 : }
2168 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResource_done, req);
2169 0 : return req;
2170 : }
2171 :
2172 0 : static void dcerpc_clusapi_CreateResource_done(struct tevent_req *subreq)
2173 : {
2174 0 : struct tevent_req *req = tevent_req_callback_data(
2175 : subreq, struct tevent_req);
2176 0 : struct dcerpc_clusapi_CreateResource_state *state = tevent_req_data(
2177 : req, struct dcerpc_clusapi_CreateResource_state);
2178 : NTSTATUS status;
2179 : TALLOC_CTX *mem_ctx;
2180 :
2181 0 : if (state->out_mem_ctx) {
2182 0 : mem_ctx = state->out_mem_ctx;
2183 : } else {
2184 0 : mem_ctx = state;
2185 : }
2186 :
2187 0 : status = dcerpc_clusapi_CreateResource_r_recv(subreq, mem_ctx);
2188 0 : TALLOC_FREE(subreq);
2189 0 : if (tevent_req_nterror(req, status)) {
2190 0 : return;
2191 : }
2192 :
2193 : /* Copy out parameters */
2194 0 : *state->orig.out.Status = *state->tmp.out.Status;
2195 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
2196 0 : *state->orig.out.hResource = *state->tmp.out.hResource;
2197 :
2198 : /* Reset temporary structure */
2199 0 : NDR_ZERO_STRUCT(state->tmp);
2200 :
2201 0 : tevent_req_done(req);
2202 : }
2203 :
2204 0 : NTSTATUS dcerpc_clusapi_CreateResource_recv(struct tevent_req *req,
2205 : TALLOC_CTX *mem_ctx)
2206 : {
2207 0 : struct dcerpc_clusapi_CreateResource_state *state = tevent_req_data(
2208 : req, struct dcerpc_clusapi_CreateResource_state);
2209 : NTSTATUS status;
2210 :
2211 0 : if (tevent_req_is_nterror(req, &status)) {
2212 0 : tevent_req_received(req);
2213 0 : return status;
2214 : }
2215 :
2216 : /* Steal possible out parameters to the callers context */
2217 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2218 :
2219 0 : tevent_req_received(req);
2220 0 : return NT_STATUS_OK;
2221 : }
2222 :
2223 0 : NTSTATUS dcerpc_clusapi_CreateResource(struct dcerpc_binding_handle *h,
2224 : TALLOC_CTX *mem_ctx,
2225 : struct policy_handle _hGroup /* [in] */,
2226 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
2227 : const char *_lpszResourceType /* [in] [charset(UTF16),ref] */,
2228 : enum clusapi_CreateResourceFlags _dwFlags /* [in] */,
2229 : WERROR *_Status /* [out] [ref] */,
2230 : WERROR *_rpc_status /* [out] [ref] */,
2231 : struct policy_handle *_hResource /* [out] [ref] */)
2232 : {
2233 : struct clusapi_CreateResource r;
2234 : NTSTATUS status;
2235 :
2236 : /* In parameters */
2237 0 : r.in.hGroup = _hGroup;
2238 0 : r.in.lpszResourceName = _lpszResourceName;
2239 0 : r.in.lpszResourceType = _lpszResourceType;
2240 0 : r.in.dwFlags = _dwFlags;
2241 :
2242 : /* Out parameters */
2243 0 : r.out.Status = _Status;
2244 0 : r.out.rpc_status = _rpc_status;
2245 0 : r.out.hResource = _hResource;
2246 :
2247 0 : status = dcerpc_clusapi_CreateResource_r(h, mem_ctx, &r);
2248 0 : if (!NT_STATUS_IS_OK(status)) {
2249 0 : return status;
2250 : }
2251 :
2252 : /* Return variables */
2253 0 : *_Status = *r.out.Status;
2254 0 : *_rpc_status = *r.out.rpc_status;
2255 0 : *_hResource = *r.out.hResource;
2256 :
2257 : /* Return result */
2258 :
2259 0 : return NT_STATUS_OK;
2260 : }
2261 :
2262 : struct dcerpc_clusapi_DeleteResource_r_state {
2263 : TALLOC_CTX *out_mem_ctx;
2264 : };
2265 :
2266 : static void dcerpc_clusapi_DeleteResource_r_done(struct tevent_req *subreq);
2267 :
2268 0 : struct tevent_req *dcerpc_clusapi_DeleteResource_r_send(TALLOC_CTX *mem_ctx,
2269 : struct tevent_context *ev,
2270 : struct dcerpc_binding_handle *h,
2271 : struct clusapi_DeleteResource *r)
2272 : {
2273 : struct tevent_req *req;
2274 : struct dcerpc_clusapi_DeleteResource_r_state *state;
2275 : struct tevent_req *subreq;
2276 :
2277 0 : req = tevent_req_create(mem_ctx, &state,
2278 : struct dcerpc_clusapi_DeleteResource_r_state);
2279 0 : if (req == NULL) {
2280 0 : return NULL;
2281 : }
2282 :
2283 0 : state->out_mem_ctx = talloc_new(state);
2284 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2285 0 : return tevent_req_post(req, ev);
2286 : }
2287 :
2288 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
2289 : NULL, &ndr_table_clusapi,
2290 0 : NDR_CLUSAPI_DELETERESOURCE, state->out_mem_ctx, r);
2291 0 : if (tevent_req_nomem(subreq, req)) {
2292 0 : return tevent_req_post(req, ev);
2293 : }
2294 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteResource_r_done, req);
2295 :
2296 0 : return req;
2297 : }
2298 :
2299 0 : static void dcerpc_clusapi_DeleteResource_r_done(struct tevent_req *subreq)
2300 : {
2301 0 : struct tevent_req *req =
2302 0 : tevent_req_callback_data(subreq,
2303 : struct tevent_req);
2304 : NTSTATUS status;
2305 :
2306 0 : status = dcerpc_binding_handle_call_recv(subreq);
2307 0 : TALLOC_FREE(subreq);
2308 0 : if (tevent_req_nterror(req, status)) {
2309 0 : return;
2310 : }
2311 :
2312 0 : tevent_req_done(req);
2313 : }
2314 :
2315 0 : NTSTATUS dcerpc_clusapi_DeleteResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2316 : {
2317 0 : struct dcerpc_clusapi_DeleteResource_r_state *state =
2318 0 : tevent_req_data(req,
2319 : struct dcerpc_clusapi_DeleteResource_r_state);
2320 : NTSTATUS status;
2321 :
2322 0 : if (tevent_req_is_nterror(req, &status)) {
2323 0 : tevent_req_received(req);
2324 0 : return status;
2325 : }
2326 :
2327 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2328 :
2329 0 : tevent_req_received(req);
2330 0 : return NT_STATUS_OK;
2331 : }
2332 :
2333 0 : NTSTATUS dcerpc_clusapi_DeleteResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteResource *r)
2334 : {
2335 : NTSTATUS status;
2336 :
2337 0 : status = dcerpc_binding_handle_call(h,
2338 : NULL, &ndr_table_clusapi,
2339 : NDR_CLUSAPI_DELETERESOURCE, mem_ctx, r);
2340 :
2341 0 : return status;
2342 : }
2343 :
2344 : struct dcerpc_clusapi_DeleteResource_state {
2345 : struct clusapi_DeleteResource orig;
2346 : struct clusapi_DeleteResource tmp;
2347 : TALLOC_CTX *out_mem_ctx;
2348 : };
2349 :
2350 : static void dcerpc_clusapi_DeleteResource_done(struct tevent_req *subreq);
2351 :
2352 0 : struct tevent_req *dcerpc_clusapi_DeleteResource_send(TALLOC_CTX *mem_ctx,
2353 : struct tevent_context *ev,
2354 : struct dcerpc_binding_handle *h,
2355 : struct policy_handle _hResource /* [in] */,
2356 : WERROR *_rpc_status /* [out] [ref] */)
2357 : {
2358 : struct tevent_req *req;
2359 : struct dcerpc_clusapi_DeleteResource_state *state;
2360 : struct tevent_req *subreq;
2361 :
2362 0 : req = tevent_req_create(mem_ctx, &state,
2363 : struct dcerpc_clusapi_DeleteResource_state);
2364 0 : if (req == NULL) {
2365 0 : return NULL;
2366 : }
2367 0 : state->out_mem_ctx = NULL;
2368 :
2369 : /* In parameters */
2370 0 : state->orig.in.hResource = _hResource;
2371 :
2372 : /* Out parameters */
2373 0 : state->orig.out.rpc_status = _rpc_status;
2374 :
2375 : /* Result */
2376 0 : NDR_ZERO_STRUCT(state->orig.out.result);
2377 :
2378 0 : state->out_mem_ctx = talloc_named_const(state, 0,
2379 : "dcerpc_clusapi_DeleteResource_out_memory");
2380 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2381 0 : return tevent_req_post(req, ev);
2382 : }
2383 :
2384 : /* make a temporary copy, that we pass to the dispatch function */
2385 0 : state->tmp = state->orig;
2386 :
2387 0 : subreq = dcerpc_clusapi_DeleteResource_r_send(state, ev, h, &state->tmp);
2388 0 : if (tevent_req_nomem(subreq, req)) {
2389 0 : return tevent_req_post(req, ev);
2390 : }
2391 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteResource_done, req);
2392 0 : return req;
2393 : }
2394 :
2395 0 : static void dcerpc_clusapi_DeleteResource_done(struct tevent_req *subreq)
2396 : {
2397 0 : struct tevent_req *req = tevent_req_callback_data(
2398 : subreq, struct tevent_req);
2399 0 : struct dcerpc_clusapi_DeleteResource_state *state = tevent_req_data(
2400 : req, struct dcerpc_clusapi_DeleteResource_state);
2401 : NTSTATUS status;
2402 : TALLOC_CTX *mem_ctx;
2403 :
2404 0 : if (state->out_mem_ctx) {
2405 0 : mem_ctx = state->out_mem_ctx;
2406 : } else {
2407 0 : mem_ctx = state;
2408 : }
2409 :
2410 0 : status = dcerpc_clusapi_DeleteResource_r_recv(subreq, mem_ctx);
2411 0 : TALLOC_FREE(subreq);
2412 0 : if (tevent_req_nterror(req, status)) {
2413 0 : return;
2414 : }
2415 :
2416 : /* Copy out parameters */
2417 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
2418 :
2419 : /* Copy result */
2420 0 : state->orig.out.result = state->tmp.out.result;
2421 :
2422 : /* Reset temporary structure */
2423 0 : NDR_ZERO_STRUCT(state->tmp);
2424 :
2425 0 : tevent_req_done(req);
2426 : }
2427 :
2428 0 : NTSTATUS dcerpc_clusapi_DeleteResource_recv(struct tevent_req *req,
2429 : TALLOC_CTX *mem_ctx,
2430 : WERROR *result)
2431 : {
2432 0 : struct dcerpc_clusapi_DeleteResource_state *state = tevent_req_data(
2433 : req, struct dcerpc_clusapi_DeleteResource_state);
2434 : NTSTATUS status;
2435 :
2436 0 : if (tevent_req_is_nterror(req, &status)) {
2437 0 : tevent_req_received(req);
2438 0 : return status;
2439 : }
2440 :
2441 : /* Steal possible out parameters to the callers context */
2442 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2443 :
2444 : /* Return result */
2445 0 : *result = state->orig.out.result;
2446 :
2447 0 : tevent_req_received(req);
2448 0 : return NT_STATUS_OK;
2449 : }
2450 :
2451 0 : NTSTATUS dcerpc_clusapi_DeleteResource(struct dcerpc_binding_handle *h,
2452 : TALLOC_CTX *mem_ctx,
2453 : struct policy_handle _hResource /* [in] */,
2454 : WERROR *_rpc_status /* [out] [ref] */,
2455 : WERROR *result)
2456 : {
2457 : struct clusapi_DeleteResource r;
2458 : NTSTATUS status;
2459 :
2460 : /* In parameters */
2461 0 : r.in.hResource = _hResource;
2462 :
2463 : /* Out parameters */
2464 0 : r.out.rpc_status = _rpc_status;
2465 :
2466 : /* Result */
2467 0 : NDR_ZERO_STRUCT(r.out.result);
2468 :
2469 0 : status = dcerpc_clusapi_DeleteResource_r(h, mem_ctx, &r);
2470 0 : if (!NT_STATUS_IS_OK(status)) {
2471 0 : return status;
2472 : }
2473 :
2474 : /* Return variables */
2475 0 : *_rpc_status = *r.out.rpc_status;
2476 :
2477 : /* Return result */
2478 0 : *result = r.out.result;
2479 :
2480 0 : return NT_STATUS_OK;
2481 : }
2482 :
2483 : struct dcerpc_clusapi_CloseResource_r_state {
2484 : TALLOC_CTX *out_mem_ctx;
2485 : };
2486 :
2487 : static void dcerpc_clusapi_CloseResource_r_done(struct tevent_req *subreq);
2488 :
2489 0 : struct tevent_req *dcerpc_clusapi_CloseResource_r_send(TALLOC_CTX *mem_ctx,
2490 : struct tevent_context *ev,
2491 : struct dcerpc_binding_handle *h,
2492 : struct clusapi_CloseResource *r)
2493 : {
2494 : struct tevent_req *req;
2495 : struct dcerpc_clusapi_CloseResource_r_state *state;
2496 : struct tevent_req *subreq;
2497 :
2498 0 : req = tevent_req_create(mem_ctx, &state,
2499 : struct dcerpc_clusapi_CloseResource_r_state);
2500 0 : if (req == NULL) {
2501 0 : return NULL;
2502 : }
2503 :
2504 0 : state->out_mem_ctx = talloc_new(state);
2505 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2506 0 : return tevent_req_post(req, ev);
2507 : }
2508 :
2509 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
2510 : NULL, &ndr_table_clusapi,
2511 0 : NDR_CLUSAPI_CLOSERESOURCE, state->out_mem_ctx, r);
2512 0 : if (tevent_req_nomem(subreq, req)) {
2513 0 : return tevent_req_post(req, ev);
2514 : }
2515 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseResource_r_done, req);
2516 :
2517 0 : return req;
2518 : }
2519 :
2520 0 : static void dcerpc_clusapi_CloseResource_r_done(struct tevent_req *subreq)
2521 : {
2522 0 : struct tevent_req *req =
2523 0 : tevent_req_callback_data(subreq,
2524 : struct tevent_req);
2525 : NTSTATUS status;
2526 :
2527 0 : status = dcerpc_binding_handle_call_recv(subreq);
2528 0 : TALLOC_FREE(subreq);
2529 0 : if (tevent_req_nterror(req, status)) {
2530 0 : return;
2531 : }
2532 :
2533 0 : tevent_req_done(req);
2534 : }
2535 :
2536 0 : NTSTATUS dcerpc_clusapi_CloseResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2537 : {
2538 0 : struct dcerpc_clusapi_CloseResource_r_state *state =
2539 0 : tevent_req_data(req,
2540 : struct dcerpc_clusapi_CloseResource_r_state);
2541 : NTSTATUS status;
2542 :
2543 0 : if (tevent_req_is_nterror(req, &status)) {
2544 0 : tevent_req_received(req);
2545 0 : return status;
2546 : }
2547 :
2548 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2549 :
2550 0 : tevent_req_received(req);
2551 0 : return NT_STATUS_OK;
2552 : }
2553 :
2554 0 : NTSTATUS dcerpc_clusapi_CloseResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseResource *r)
2555 : {
2556 : NTSTATUS status;
2557 :
2558 0 : status = dcerpc_binding_handle_call(h,
2559 : NULL, &ndr_table_clusapi,
2560 : NDR_CLUSAPI_CLOSERESOURCE, mem_ctx, r);
2561 :
2562 0 : return status;
2563 : }
2564 :
2565 : struct dcerpc_clusapi_CloseResource_state {
2566 : struct clusapi_CloseResource orig;
2567 : struct clusapi_CloseResource tmp;
2568 : TALLOC_CTX *out_mem_ctx;
2569 : };
2570 :
2571 : static void dcerpc_clusapi_CloseResource_done(struct tevent_req *subreq);
2572 :
2573 0 : struct tevent_req *dcerpc_clusapi_CloseResource_send(TALLOC_CTX *mem_ctx,
2574 : struct tevent_context *ev,
2575 : struct dcerpc_binding_handle *h,
2576 : struct policy_handle *_Resource /* [in,out] [ref] */)
2577 : {
2578 : struct tevent_req *req;
2579 : struct dcerpc_clusapi_CloseResource_state *state;
2580 : struct tevent_req *subreq;
2581 :
2582 0 : req = tevent_req_create(mem_ctx, &state,
2583 : struct dcerpc_clusapi_CloseResource_state);
2584 0 : if (req == NULL) {
2585 0 : return NULL;
2586 : }
2587 0 : state->out_mem_ctx = NULL;
2588 :
2589 : /* In parameters */
2590 0 : state->orig.in.Resource = _Resource;
2591 :
2592 : /* Out parameters */
2593 0 : state->orig.out.Resource = _Resource;
2594 :
2595 : /* Result */
2596 0 : NDR_ZERO_STRUCT(state->orig.out.result);
2597 :
2598 0 : state->out_mem_ctx = talloc_named_const(state, 0,
2599 : "dcerpc_clusapi_CloseResource_out_memory");
2600 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2601 0 : return tevent_req_post(req, ev);
2602 : }
2603 :
2604 : /* make a temporary copy, that we pass to the dispatch function */
2605 0 : state->tmp = state->orig;
2606 :
2607 0 : subreq = dcerpc_clusapi_CloseResource_r_send(state, ev, h, &state->tmp);
2608 0 : if (tevent_req_nomem(subreq, req)) {
2609 0 : return tevent_req_post(req, ev);
2610 : }
2611 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseResource_done, req);
2612 0 : return req;
2613 : }
2614 :
2615 0 : static void dcerpc_clusapi_CloseResource_done(struct tevent_req *subreq)
2616 : {
2617 0 : struct tevent_req *req = tevent_req_callback_data(
2618 : subreq, struct tevent_req);
2619 0 : struct dcerpc_clusapi_CloseResource_state *state = tevent_req_data(
2620 : req, struct dcerpc_clusapi_CloseResource_state);
2621 : NTSTATUS status;
2622 : TALLOC_CTX *mem_ctx;
2623 :
2624 0 : if (state->out_mem_ctx) {
2625 0 : mem_ctx = state->out_mem_ctx;
2626 : } else {
2627 0 : mem_ctx = state;
2628 : }
2629 :
2630 0 : status = dcerpc_clusapi_CloseResource_r_recv(subreq, mem_ctx);
2631 0 : TALLOC_FREE(subreq);
2632 0 : if (tevent_req_nterror(req, status)) {
2633 0 : return;
2634 : }
2635 :
2636 : /* Copy out parameters */
2637 0 : *state->orig.out.Resource = *state->tmp.out.Resource;
2638 :
2639 : /* Copy result */
2640 0 : state->orig.out.result = state->tmp.out.result;
2641 :
2642 : /* Reset temporary structure */
2643 0 : NDR_ZERO_STRUCT(state->tmp);
2644 :
2645 0 : tevent_req_done(req);
2646 : }
2647 :
2648 0 : NTSTATUS dcerpc_clusapi_CloseResource_recv(struct tevent_req *req,
2649 : TALLOC_CTX *mem_ctx,
2650 : WERROR *result)
2651 : {
2652 0 : struct dcerpc_clusapi_CloseResource_state *state = tevent_req_data(
2653 : req, struct dcerpc_clusapi_CloseResource_state);
2654 : NTSTATUS status;
2655 :
2656 0 : if (tevent_req_is_nterror(req, &status)) {
2657 0 : tevent_req_received(req);
2658 0 : return status;
2659 : }
2660 :
2661 : /* Steal possible out parameters to the callers context */
2662 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2663 :
2664 : /* Return result */
2665 0 : *result = state->orig.out.result;
2666 :
2667 0 : tevent_req_received(req);
2668 0 : return NT_STATUS_OK;
2669 : }
2670 :
2671 0 : NTSTATUS dcerpc_clusapi_CloseResource(struct dcerpc_binding_handle *h,
2672 : TALLOC_CTX *mem_ctx,
2673 : struct policy_handle *_Resource /* [in,out] [ref] */,
2674 : WERROR *result)
2675 : {
2676 : struct clusapi_CloseResource r;
2677 : NTSTATUS status;
2678 :
2679 : /* In parameters */
2680 0 : r.in.Resource = _Resource;
2681 :
2682 : /* Out parameters */
2683 0 : r.out.Resource = _Resource;
2684 :
2685 : /* Result */
2686 0 : NDR_ZERO_STRUCT(r.out.result);
2687 :
2688 0 : status = dcerpc_clusapi_CloseResource_r(h, mem_ctx, &r);
2689 0 : if (!NT_STATUS_IS_OK(status)) {
2690 0 : return status;
2691 : }
2692 :
2693 : /* Return variables */
2694 0 : *_Resource = *r.out.Resource;
2695 :
2696 : /* Return result */
2697 0 : *result = r.out.result;
2698 :
2699 0 : return NT_STATUS_OK;
2700 : }
2701 :
2702 : struct dcerpc_clusapi_GetResourceState_r_state {
2703 : TALLOC_CTX *out_mem_ctx;
2704 : };
2705 :
2706 : static void dcerpc_clusapi_GetResourceState_r_done(struct tevent_req *subreq);
2707 :
2708 0 : struct tevent_req *dcerpc_clusapi_GetResourceState_r_send(TALLOC_CTX *mem_ctx,
2709 : struct tevent_context *ev,
2710 : struct dcerpc_binding_handle *h,
2711 : struct clusapi_GetResourceState *r)
2712 : {
2713 : struct tevent_req *req;
2714 : struct dcerpc_clusapi_GetResourceState_r_state *state;
2715 : struct tevent_req *subreq;
2716 :
2717 0 : req = tevent_req_create(mem_ctx, &state,
2718 : struct dcerpc_clusapi_GetResourceState_r_state);
2719 0 : if (req == NULL) {
2720 0 : return NULL;
2721 : }
2722 :
2723 0 : state->out_mem_ctx = talloc_new(state);
2724 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2725 0 : return tevent_req_post(req, ev);
2726 : }
2727 :
2728 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
2729 : NULL, &ndr_table_clusapi,
2730 0 : NDR_CLUSAPI_GETRESOURCESTATE, state->out_mem_ctx, r);
2731 0 : if (tevent_req_nomem(subreq, req)) {
2732 0 : return tevent_req_post(req, ev);
2733 : }
2734 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceState_r_done, req);
2735 :
2736 0 : return req;
2737 : }
2738 :
2739 0 : static void dcerpc_clusapi_GetResourceState_r_done(struct tevent_req *subreq)
2740 : {
2741 0 : struct tevent_req *req =
2742 0 : tevent_req_callback_data(subreq,
2743 : struct tevent_req);
2744 : NTSTATUS status;
2745 :
2746 0 : status = dcerpc_binding_handle_call_recv(subreq);
2747 0 : TALLOC_FREE(subreq);
2748 0 : if (tevent_req_nterror(req, status)) {
2749 0 : return;
2750 : }
2751 :
2752 0 : tevent_req_done(req);
2753 : }
2754 :
2755 0 : NTSTATUS dcerpc_clusapi_GetResourceState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2756 : {
2757 0 : struct dcerpc_clusapi_GetResourceState_r_state *state =
2758 0 : tevent_req_data(req,
2759 : struct dcerpc_clusapi_GetResourceState_r_state);
2760 : NTSTATUS status;
2761 :
2762 0 : if (tevent_req_is_nterror(req, &status)) {
2763 0 : tevent_req_received(req);
2764 0 : return status;
2765 : }
2766 :
2767 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2768 :
2769 0 : tevent_req_received(req);
2770 0 : return NT_STATUS_OK;
2771 : }
2772 :
2773 0 : NTSTATUS dcerpc_clusapi_GetResourceState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetResourceState *r)
2774 : {
2775 : NTSTATUS status;
2776 :
2777 0 : status = dcerpc_binding_handle_call(h,
2778 : NULL, &ndr_table_clusapi,
2779 : NDR_CLUSAPI_GETRESOURCESTATE, mem_ctx, r);
2780 :
2781 0 : return status;
2782 : }
2783 :
2784 : struct dcerpc_clusapi_GetResourceState_state {
2785 : struct clusapi_GetResourceState orig;
2786 : struct clusapi_GetResourceState tmp;
2787 : TALLOC_CTX *out_mem_ctx;
2788 : };
2789 :
2790 : static void dcerpc_clusapi_GetResourceState_done(struct tevent_req *subreq);
2791 :
2792 0 : struct tevent_req *dcerpc_clusapi_GetResourceState_send(TALLOC_CTX *mem_ctx,
2793 : struct tevent_context *ev,
2794 : struct dcerpc_binding_handle *h,
2795 : struct policy_handle _hResource /* [in] */,
2796 : enum clusapi_ClusterResourceState *_State /* [out] [ref] */,
2797 : const char **_NodeName /* [out] [charset(UTF16),ref] */,
2798 : const char **_GroupName /* [out] [charset(UTF16),ref] */,
2799 : WERROR *_rpc_status /* [out] [ref] */)
2800 : {
2801 : struct tevent_req *req;
2802 : struct dcerpc_clusapi_GetResourceState_state *state;
2803 : struct tevent_req *subreq;
2804 :
2805 0 : req = tevent_req_create(mem_ctx, &state,
2806 : struct dcerpc_clusapi_GetResourceState_state);
2807 0 : if (req == NULL) {
2808 0 : return NULL;
2809 : }
2810 0 : state->out_mem_ctx = NULL;
2811 :
2812 : /* In parameters */
2813 0 : state->orig.in.hResource = _hResource;
2814 :
2815 : /* Out parameters */
2816 0 : state->orig.out.State = _State;
2817 0 : state->orig.out.NodeName = _NodeName;
2818 0 : state->orig.out.GroupName = _GroupName;
2819 0 : state->orig.out.rpc_status = _rpc_status;
2820 :
2821 : /* Result */
2822 0 : NDR_ZERO_STRUCT(state->orig.out.result);
2823 :
2824 0 : state->out_mem_ctx = talloc_named_const(state, 0,
2825 : "dcerpc_clusapi_GetResourceState_out_memory");
2826 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2827 0 : return tevent_req_post(req, ev);
2828 : }
2829 :
2830 : /* make a temporary copy, that we pass to the dispatch function */
2831 0 : state->tmp = state->orig;
2832 :
2833 0 : subreq = dcerpc_clusapi_GetResourceState_r_send(state, ev, h, &state->tmp);
2834 0 : if (tevent_req_nomem(subreq, req)) {
2835 0 : return tevent_req_post(req, ev);
2836 : }
2837 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceState_done, req);
2838 0 : return req;
2839 : }
2840 :
2841 0 : static void dcerpc_clusapi_GetResourceState_done(struct tevent_req *subreq)
2842 : {
2843 0 : struct tevent_req *req = tevent_req_callback_data(
2844 : subreq, struct tevent_req);
2845 0 : struct dcerpc_clusapi_GetResourceState_state *state = tevent_req_data(
2846 : req, struct dcerpc_clusapi_GetResourceState_state);
2847 : NTSTATUS status;
2848 : TALLOC_CTX *mem_ctx;
2849 :
2850 0 : if (state->out_mem_ctx) {
2851 0 : mem_ctx = state->out_mem_ctx;
2852 : } else {
2853 0 : mem_ctx = state;
2854 : }
2855 :
2856 0 : status = dcerpc_clusapi_GetResourceState_r_recv(subreq, mem_ctx);
2857 0 : TALLOC_FREE(subreq);
2858 0 : if (tevent_req_nterror(req, status)) {
2859 0 : return;
2860 : }
2861 :
2862 : /* Copy out parameters */
2863 0 : *state->orig.out.State = *state->tmp.out.State;
2864 0 : *state->orig.out.NodeName = *state->tmp.out.NodeName;
2865 0 : *state->orig.out.GroupName = *state->tmp.out.GroupName;
2866 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
2867 :
2868 : /* Copy result */
2869 0 : state->orig.out.result = state->tmp.out.result;
2870 :
2871 : /* Reset temporary structure */
2872 0 : NDR_ZERO_STRUCT(state->tmp);
2873 :
2874 0 : tevent_req_done(req);
2875 : }
2876 :
2877 0 : NTSTATUS dcerpc_clusapi_GetResourceState_recv(struct tevent_req *req,
2878 : TALLOC_CTX *mem_ctx,
2879 : WERROR *result)
2880 : {
2881 0 : struct dcerpc_clusapi_GetResourceState_state *state = tevent_req_data(
2882 : req, struct dcerpc_clusapi_GetResourceState_state);
2883 : NTSTATUS status;
2884 :
2885 0 : if (tevent_req_is_nterror(req, &status)) {
2886 0 : tevent_req_received(req);
2887 0 : return status;
2888 : }
2889 :
2890 : /* Steal possible out parameters to the callers context */
2891 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
2892 :
2893 : /* Return result */
2894 0 : *result = state->orig.out.result;
2895 :
2896 0 : tevent_req_received(req);
2897 0 : return NT_STATUS_OK;
2898 : }
2899 :
2900 0 : NTSTATUS dcerpc_clusapi_GetResourceState(struct dcerpc_binding_handle *h,
2901 : TALLOC_CTX *mem_ctx,
2902 : struct policy_handle _hResource /* [in] */,
2903 : enum clusapi_ClusterResourceState *_State /* [out] [ref] */,
2904 : const char **_NodeName /* [out] [charset(UTF16),ref] */,
2905 : const char **_GroupName /* [out] [charset(UTF16),ref] */,
2906 : WERROR *_rpc_status /* [out] [ref] */,
2907 : WERROR *result)
2908 : {
2909 : struct clusapi_GetResourceState r;
2910 : NTSTATUS status;
2911 :
2912 : /* In parameters */
2913 0 : r.in.hResource = _hResource;
2914 :
2915 : /* Out parameters */
2916 0 : r.out.State = _State;
2917 0 : r.out.NodeName = _NodeName;
2918 0 : r.out.GroupName = _GroupName;
2919 0 : r.out.rpc_status = _rpc_status;
2920 :
2921 : /* Result */
2922 0 : NDR_ZERO_STRUCT(r.out.result);
2923 :
2924 0 : status = dcerpc_clusapi_GetResourceState_r(h, mem_ctx, &r);
2925 0 : if (!NT_STATUS_IS_OK(status)) {
2926 0 : return status;
2927 : }
2928 :
2929 : /* Return variables */
2930 0 : *_State = *r.out.State;
2931 0 : *_NodeName = *r.out.NodeName;
2932 0 : *_GroupName = *r.out.GroupName;
2933 0 : *_rpc_status = *r.out.rpc_status;
2934 :
2935 : /* Return result */
2936 0 : *result = r.out.result;
2937 :
2938 0 : return NT_STATUS_OK;
2939 : }
2940 :
2941 : struct dcerpc_clusapi_SetResourceName_r_state {
2942 : TALLOC_CTX *out_mem_ctx;
2943 : };
2944 :
2945 : static void dcerpc_clusapi_SetResourceName_r_done(struct tevent_req *subreq);
2946 :
2947 0 : struct tevent_req *dcerpc_clusapi_SetResourceName_r_send(TALLOC_CTX *mem_ctx,
2948 : struct tevent_context *ev,
2949 : struct dcerpc_binding_handle *h,
2950 : struct clusapi_SetResourceName *r)
2951 : {
2952 : struct tevent_req *req;
2953 : struct dcerpc_clusapi_SetResourceName_r_state *state;
2954 : struct tevent_req *subreq;
2955 :
2956 0 : req = tevent_req_create(mem_ctx, &state,
2957 : struct dcerpc_clusapi_SetResourceName_r_state);
2958 0 : if (req == NULL) {
2959 0 : return NULL;
2960 : }
2961 :
2962 0 : state->out_mem_ctx = talloc_new(state);
2963 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
2964 0 : return tevent_req_post(req, ev);
2965 : }
2966 :
2967 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
2968 : NULL, &ndr_table_clusapi,
2969 0 : NDR_CLUSAPI_SETRESOURCENAME, state->out_mem_ctx, r);
2970 0 : if (tevent_req_nomem(subreq, req)) {
2971 0 : return tevent_req_post(req, ev);
2972 : }
2973 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetResourceName_r_done, req);
2974 :
2975 0 : return req;
2976 : }
2977 :
2978 0 : static void dcerpc_clusapi_SetResourceName_r_done(struct tevent_req *subreq)
2979 : {
2980 0 : struct tevent_req *req =
2981 0 : tevent_req_callback_data(subreq,
2982 : struct tevent_req);
2983 : NTSTATUS status;
2984 :
2985 0 : status = dcerpc_binding_handle_call_recv(subreq);
2986 0 : TALLOC_FREE(subreq);
2987 0 : if (tevent_req_nterror(req, status)) {
2988 0 : return;
2989 : }
2990 :
2991 0 : tevent_req_done(req);
2992 : }
2993 :
2994 0 : NTSTATUS dcerpc_clusapi_SetResourceName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2995 : {
2996 0 : struct dcerpc_clusapi_SetResourceName_r_state *state =
2997 0 : tevent_req_data(req,
2998 : struct dcerpc_clusapi_SetResourceName_r_state);
2999 : NTSTATUS status;
3000 :
3001 0 : if (tevent_req_is_nterror(req, &status)) {
3002 0 : tevent_req_received(req);
3003 0 : return status;
3004 : }
3005 :
3006 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3007 :
3008 0 : tevent_req_received(req);
3009 0 : return NT_STATUS_OK;
3010 : }
3011 :
3012 0 : NTSTATUS dcerpc_clusapi_SetResourceName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetResourceName *r)
3013 : {
3014 : NTSTATUS status;
3015 :
3016 0 : status = dcerpc_binding_handle_call(h,
3017 : NULL, &ndr_table_clusapi,
3018 : NDR_CLUSAPI_SETRESOURCENAME, mem_ctx, r);
3019 :
3020 0 : return status;
3021 : }
3022 :
3023 : struct dcerpc_clusapi_SetResourceName_state {
3024 : struct clusapi_SetResourceName orig;
3025 : struct clusapi_SetResourceName tmp;
3026 : TALLOC_CTX *out_mem_ctx;
3027 : };
3028 :
3029 : static void dcerpc_clusapi_SetResourceName_done(struct tevent_req *subreq);
3030 :
3031 0 : struct tevent_req *dcerpc_clusapi_SetResourceName_send(TALLOC_CTX *mem_ctx,
3032 : struct tevent_context *ev,
3033 : struct dcerpc_binding_handle *h,
3034 : struct policy_handle _hResource /* [in] */,
3035 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
3036 : WERROR *_rpc_status /* [out] [ref] */)
3037 : {
3038 : struct tevent_req *req;
3039 : struct dcerpc_clusapi_SetResourceName_state *state;
3040 : struct tevent_req *subreq;
3041 :
3042 0 : req = tevent_req_create(mem_ctx, &state,
3043 : struct dcerpc_clusapi_SetResourceName_state);
3044 0 : if (req == NULL) {
3045 0 : return NULL;
3046 : }
3047 0 : state->out_mem_ctx = NULL;
3048 :
3049 : /* In parameters */
3050 0 : state->orig.in.hResource = _hResource;
3051 0 : state->orig.in.lpszResourceName = _lpszResourceName;
3052 :
3053 : /* Out parameters */
3054 0 : state->orig.out.rpc_status = _rpc_status;
3055 :
3056 : /* Result */
3057 0 : NDR_ZERO_STRUCT(state->orig.out.result);
3058 :
3059 0 : state->out_mem_ctx = talloc_named_const(state, 0,
3060 : "dcerpc_clusapi_SetResourceName_out_memory");
3061 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3062 0 : return tevent_req_post(req, ev);
3063 : }
3064 :
3065 : /* make a temporary copy, that we pass to the dispatch function */
3066 0 : state->tmp = state->orig;
3067 :
3068 0 : subreq = dcerpc_clusapi_SetResourceName_r_send(state, ev, h, &state->tmp);
3069 0 : if (tevent_req_nomem(subreq, req)) {
3070 0 : return tevent_req_post(req, ev);
3071 : }
3072 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetResourceName_done, req);
3073 0 : return req;
3074 : }
3075 :
3076 0 : static void dcerpc_clusapi_SetResourceName_done(struct tevent_req *subreq)
3077 : {
3078 0 : struct tevent_req *req = tevent_req_callback_data(
3079 : subreq, struct tevent_req);
3080 0 : struct dcerpc_clusapi_SetResourceName_state *state = tevent_req_data(
3081 : req, struct dcerpc_clusapi_SetResourceName_state);
3082 : NTSTATUS status;
3083 : TALLOC_CTX *mem_ctx;
3084 :
3085 0 : if (state->out_mem_ctx) {
3086 0 : mem_ctx = state->out_mem_ctx;
3087 : } else {
3088 0 : mem_ctx = state;
3089 : }
3090 :
3091 0 : status = dcerpc_clusapi_SetResourceName_r_recv(subreq, mem_ctx);
3092 0 : TALLOC_FREE(subreq);
3093 0 : if (tevent_req_nterror(req, status)) {
3094 0 : return;
3095 : }
3096 :
3097 : /* Copy out parameters */
3098 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
3099 :
3100 : /* Copy result */
3101 0 : state->orig.out.result = state->tmp.out.result;
3102 :
3103 : /* Reset temporary structure */
3104 0 : NDR_ZERO_STRUCT(state->tmp);
3105 :
3106 0 : tevent_req_done(req);
3107 : }
3108 :
3109 0 : NTSTATUS dcerpc_clusapi_SetResourceName_recv(struct tevent_req *req,
3110 : TALLOC_CTX *mem_ctx,
3111 : WERROR *result)
3112 : {
3113 0 : struct dcerpc_clusapi_SetResourceName_state *state = tevent_req_data(
3114 : req, struct dcerpc_clusapi_SetResourceName_state);
3115 : NTSTATUS status;
3116 :
3117 0 : if (tevent_req_is_nterror(req, &status)) {
3118 0 : tevent_req_received(req);
3119 0 : return status;
3120 : }
3121 :
3122 : /* Steal possible out parameters to the callers context */
3123 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3124 :
3125 : /* Return result */
3126 0 : *result = state->orig.out.result;
3127 :
3128 0 : tevent_req_received(req);
3129 0 : return NT_STATUS_OK;
3130 : }
3131 :
3132 0 : NTSTATUS dcerpc_clusapi_SetResourceName(struct dcerpc_binding_handle *h,
3133 : TALLOC_CTX *mem_ctx,
3134 : struct policy_handle _hResource /* [in] */,
3135 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
3136 : WERROR *_rpc_status /* [out] [ref] */,
3137 : WERROR *result)
3138 : {
3139 : struct clusapi_SetResourceName r;
3140 : NTSTATUS status;
3141 :
3142 : /* In parameters */
3143 0 : r.in.hResource = _hResource;
3144 0 : r.in.lpszResourceName = _lpszResourceName;
3145 :
3146 : /* Out parameters */
3147 0 : r.out.rpc_status = _rpc_status;
3148 :
3149 : /* Result */
3150 0 : NDR_ZERO_STRUCT(r.out.result);
3151 :
3152 0 : status = dcerpc_clusapi_SetResourceName_r(h, mem_ctx, &r);
3153 0 : if (!NT_STATUS_IS_OK(status)) {
3154 0 : return status;
3155 : }
3156 :
3157 : /* Return variables */
3158 0 : *_rpc_status = *r.out.rpc_status;
3159 :
3160 : /* Return result */
3161 0 : *result = r.out.result;
3162 :
3163 0 : return NT_STATUS_OK;
3164 : }
3165 :
3166 : struct dcerpc_clusapi_GetResourceId_r_state {
3167 : TALLOC_CTX *out_mem_ctx;
3168 : };
3169 :
3170 : static void dcerpc_clusapi_GetResourceId_r_done(struct tevent_req *subreq);
3171 :
3172 0 : struct tevent_req *dcerpc_clusapi_GetResourceId_r_send(TALLOC_CTX *mem_ctx,
3173 : struct tevent_context *ev,
3174 : struct dcerpc_binding_handle *h,
3175 : struct clusapi_GetResourceId *r)
3176 : {
3177 : struct tevent_req *req;
3178 : struct dcerpc_clusapi_GetResourceId_r_state *state;
3179 : struct tevent_req *subreq;
3180 :
3181 0 : req = tevent_req_create(mem_ctx, &state,
3182 : struct dcerpc_clusapi_GetResourceId_r_state);
3183 0 : if (req == NULL) {
3184 0 : return NULL;
3185 : }
3186 :
3187 0 : state->out_mem_ctx = talloc_new(state);
3188 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3189 0 : return tevent_req_post(req, ev);
3190 : }
3191 :
3192 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
3193 : NULL, &ndr_table_clusapi,
3194 0 : NDR_CLUSAPI_GETRESOURCEID, state->out_mem_ctx, r);
3195 0 : if (tevent_req_nomem(subreq, req)) {
3196 0 : return tevent_req_post(req, ev);
3197 : }
3198 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceId_r_done, req);
3199 :
3200 0 : return req;
3201 : }
3202 :
3203 0 : static void dcerpc_clusapi_GetResourceId_r_done(struct tevent_req *subreq)
3204 : {
3205 0 : struct tevent_req *req =
3206 0 : tevent_req_callback_data(subreq,
3207 : struct tevent_req);
3208 : NTSTATUS status;
3209 :
3210 0 : status = dcerpc_binding_handle_call_recv(subreq);
3211 0 : TALLOC_FREE(subreq);
3212 0 : if (tevent_req_nterror(req, status)) {
3213 0 : return;
3214 : }
3215 :
3216 0 : tevent_req_done(req);
3217 : }
3218 :
3219 0 : NTSTATUS dcerpc_clusapi_GetResourceId_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3220 : {
3221 0 : struct dcerpc_clusapi_GetResourceId_r_state *state =
3222 0 : tevent_req_data(req,
3223 : struct dcerpc_clusapi_GetResourceId_r_state);
3224 : NTSTATUS status;
3225 :
3226 0 : if (tevent_req_is_nterror(req, &status)) {
3227 0 : tevent_req_received(req);
3228 0 : return status;
3229 : }
3230 :
3231 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3232 :
3233 0 : tevent_req_received(req);
3234 0 : return NT_STATUS_OK;
3235 : }
3236 :
3237 0 : NTSTATUS dcerpc_clusapi_GetResourceId_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetResourceId *r)
3238 : {
3239 : NTSTATUS status;
3240 :
3241 0 : status = dcerpc_binding_handle_call(h,
3242 : NULL, &ndr_table_clusapi,
3243 : NDR_CLUSAPI_GETRESOURCEID, mem_ctx, r);
3244 :
3245 0 : return status;
3246 : }
3247 :
3248 : struct dcerpc_clusapi_GetResourceId_state {
3249 : struct clusapi_GetResourceId orig;
3250 : struct clusapi_GetResourceId tmp;
3251 : TALLOC_CTX *out_mem_ctx;
3252 : };
3253 :
3254 : static void dcerpc_clusapi_GetResourceId_done(struct tevent_req *subreq);
3255 :
3256 0 : struct tevent_req *dcerpc_clusapi_GetResourceId_send(TALLOC_CTX *mem_ctx,
3257 : struct tevent_context *ev,
3258 : struct dcerpc_binding_handle *h,
3259 : struct policy_handle _hResource /* [in] */,
3260 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
3261 : WERROR *_rpc_status /* [out] [ref] */)
3262 : {
3263 : struct tevent_req *req;
3264 : struct dcerpc_clusapi_GetResourceId_state *state;
3265 : struct tevent_req *subreq;
3266 :
3267 0 : req = tevent_req_create(mem_ctx, &state,
3268 : struct dcerpc_clusapi_GetResourceId_state);
3269 0 : if (req == NULL) {
3270 0 : return NULL;
3271 : }
3272 0 : state->out_mem_ctx = NULL;
3273 :
3274 : /* In parameters */
3275 0 : state->orig.in.hResource = _hResource;
3276 :
3277 : /* Out parameters */
3278 0 : state->orig.out.pGuid = _pGuid;
3279 0 : state->orig.out.rpc_status = _rpc_status;
3280 :
3281 : /* Result */
3282 0 : NDR_ZERO_STRUCT(state->orig.out.result);
3283 :
3284 0 : state->out_mem_ctx = talloc_named_const(state, 0,
3285 : "dcerpc_clusapi_GetResourceId_out_memory");
3286 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3287 0 : return tevent_req_post(req, ev);
3288 : }
3289 :
3290 : /* make a temporary copy, that we pass to the dispatch function */
3291 0 : state->tmp = state->orig;
3292 :
3293 0 : subreq = dcerpc_clusapi_GetResourceId_r_send(state, ev, h, &state->tmp);
3294 0 : if (tevent_req_nomem(subreq, req)) {
3295 0 : return tevent_req_post(req, ev);
3296 : }
3297 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceId_done, req);
3298 0 : return req;
3299 : }
3300 :
3301 0 : static void dcerpc_clusapi_GetResourceId_done(struct tevent_req *subreq)
3302 : {
3303 0 : struct tevent_req *req = tevent_req_callback_data(
3304 : subreq, struct tevent_req);
3305 0 : struct dcerpc_clusapi_GetResourceId_state *state = tevent_req_data(
3306 : req, struct dcerpc_clusapi_GetResourceId_state);
3307 : NTSTATUS status;
3308 : TALLOC_CTX *mem_ctx;
3309 :
3310 0 : if (state->out_mem_ctx) {
3311 0 : mem_ctx = state->out_mem_ctx;
3312 : } else {
3313 0 : mem_ctx = state;
3314 : }
3315 :
3316 0 : status = dcerpc_clusapi_GetResourceId_r_recv(subreq, mem_ctx);
3317 0 : TALLOC_FREE(subreq);
3318 0 : if (tevent_req_nterror(req, status)) {
3319 0 : return;
3320 : }
3321 :
3322 : /* Copy out parameters */
3323 0 : *state->orig.out.pGuid = *state->tmp.out.pGuid;
3324 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
3325 :
3326 : /* Copy result */
3327 0 : state->orig.out.result = state->tmp.out.result;
3328 :
3329 : /* Reset temporary structure */
3330 0 : NDR_ZERO_STRUCT(state->tmp);
3331 :
3332 0 : tevent_req_done(req);
3333 : }
3334 :
3335 0 : NTSTATUS dcerpc_clusapi_GetResourceId_recv(struct tevent_req *req,
3336 : TALLOC_CTX *mem_ctx,
3337 : WERROR *result)
3338 : {
3339 0 : struct dcerpc_clusapi_GetResourceId_state *state = tevent_req_data(
3340 : req, struct dcerpc_clusapi_GetResourceId_state);
3341 : NTSTATUS status;
3342 :
3343 0 : if (tevent_req_is_nterror(req, &status)) {
3344 0 : tevent_req_received(req);
3345 0 : return status;
3346 : }
3347 :
3348 : /* Steal possible out parameters to the callers context */
3349 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3350 :
3351 : /* Return result */
3352 0 : *result = state->orig.out.result;
3353 :
3354 0 : tevent_req_received(req);
3355 0 : return NT_STATUS_OK;
3356 : }
3357 :
3358 0 : NTSTATUS dcerpc_clusapi_GetResourceId(struct dcerpc_binding_handle *h,
3359 : TALLOC_CTX *mem_ctx,
3360 : struct policy_handle _hResource /* [in] */,
3361 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
3362 : WERROR *_rpc_status /* [out] [ref] */,
3363 : WERROR *result)
3364 : {
3365 : struct clusapi_GetResourceId r;
3366 : NTSTATUS status;
3367 :
3368 : /* In parameters */
3369 0 : r.in.hResource = _hResource;
3370 :
3371 : /* Out parameters */
3372 0 : r.out.pGuid = _pGuid;
3373 0 : r.out.rpc_status = _rpc_status;
3374 :
3375 : /* Result */
3376 0 : NDR_ZERO_STRUCT(r.out.result);
3377 :
3378 0 : status = dcerpc_clusapi_GetResourceId_r(h, mem_ctx, &r);
3379 0 : if (!NT_STATUS_IS_OK(status)) {
3380 0 : return status;
3381 : }
3382 :
3383 : /* Return variables */
3384 0 : *_pGuid = *r.out.pGuid;
3385 0 : *_rpc_status = *r.out.rpc_status;
3386 :
3387 : /* Return result */
3388 0 : *result = r.out.result;
3389 :
3390 0 : return NT_STATUS_OK;
3391 : }
3392 :
3393 : struct dcerpc_clusapi_GetResourceType_r_state {
3394 : TALLOC_CTX *out_mem_ctx;
3395 : };
3396 :
3397 : static void dcerpc_clusapi_GetResourceType_r_done(struct tevent_req *subreq);
3398 :
3399 0 : struct tevent_req *dcerpc_clusapi_GetResourceType_r_send(TALLOC_CTX *mem_ctx,
3400 : struct tevent_context *ev,
3401 : struct dcerpc_binding_handle *h,
3402 : struct clusapi_GetResourceType *r)
3403 : {
3404 : struct tevent_req *req;
3405 : struct dcerpc_clusapi_GetResourceType_r_state *state;
3406 : struct tevent_req *subreq;
3407 :
3408 0 : req = tevent_req_create(mem_ctx, &state,
3409 : struct dcerpc_clusapi_GetResourceType_r_state);
3410 0 : if (req == NULL) {
3411 0 : return NULL;
3412 : }
3413 :
3414 0 : state->out_mem_ctx = talloc_new(state);
3415 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3416 0 : return tevent_req_post(req, ev);
3417 : }
3418 :
3419 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
3420 : NULL, &ndr_table_clusapi,
3421 0 : NDR_CLUSAPI_GETRESOURCETYPE, state->out_mem_ctx, r);
3422 0 : if (tevent_req_nomem(subreq, req)) {
3423 0 : return tevent_req_post(req, ev);
3424 : }
3425 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceType_r_done, req);
3426 :
3427 0 : return req;
3428 : }
3429 :
3430 0 : static void dcerpc_clusapi_GetResourceType_r_done(struct tevent_req *subreq)
3431 : {
3432 0 : struct tevent_req *req =
3433 0 : tevent_req_callback_data(subreq,
3434 : struct tevent_req);
3435 : NTSTATUS status;
3436 :
3437 0 : status = dcerpc_binding_handle_call_recv(subreq);
3438 0 : TALLOC_FREE(subreq);
3439 0 : if (tevent_req_nterror(req, status)) {
3440 0 : return;
3441 : }
3442 :
3443 0 : tevent_req_done(req);
3444 : }
3445 :
3446 0 : NTSTATUS dcerpc_clusapi_GetResourceType_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3447 : {
3448 0 : struct dcerpc_clusapi_GetResourceType_r_state *state =
3449 0 : tevent_req_data(req,
3450 : struct dcerpc_clusapi_GetResourceType_r_state);
3451 : NTSTATUS status;
3452 :
3453 0 : if (tevent_req_is_nterror(req, &status)) {
3454 0 : tevent_req_received(req);
3455 0 : return status;
3456 : }
3457 :
3458 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3459 :
3460 0 : tevent_req_received(req);
3461 0 : return NT_STATUS_OK;
3462 : }
3463 :
3464 0 : NTSTATUS dcerpc_clusapi_GetResourceType_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetResourceType *r)
3465 : {
3466 : NTSTATUS status;
3467 :
3468 0 : status = dcerpc_binding_handle_call(h,
3469 : NULL, &ndr_table_clusapi,
3470 : NDR_CLUSAPI_GETRESOURCETYPE, mem_ctx, r);
3471 :
3472 0 : return status;
3473 : }
3474 :
3475 : struct dcerpc_clusapi_GetResourceType_state {
3476 : struct clusapi_GetResourceType orig;
3477 : struct clusapi_GetResourceType tmp;
3478 : TALLOC_CTX *out_mem_ctx;
3479 : };
3480 :
3481 : static void dcerpc_clusapi_GetResourceType_done(struct tevent_req *subreq);
3482 :
3483 0 : struct tevent_req *dcerpc_clusapi_GetResourceType_send(TALLOC_CTX *mem_ctx,
3484 : struct tevent_context *ev,
3485 : struct dcerpc_binding_handle *h,
3486 : struct policy_handle _hResource /* [in] */,
3487 : const char **_lpszResourceType /* [out] [charset(UTF16),ref] */,
3488 : WERROR *_rpc_status /* [out] [ref] */)
3489 : {
3490 : struct tevent_req *req;
3491 : struct dcerpc_clusapi_GetResourceType_state *state;
3492 : struct tevent_req *subreq;
3493 :
3494 0 : req = tevent_req_create(mem_ctx, &state,
3495 : struct dcerpc_clusapi_GetResourceType_state);
3496 0 : if (req == NULL) {
3497 0 : return NULL;
3498 : }
3499 0 : state->out_mem_ctx = NULL;
3500 :
3501 : /* In parameters */
3502 0 : state->orig.in.hResource = _hResource;
3503 :
3504 : /* Out parameters */
3505 0 : state->orig.out.lpszResourceType = _lpszResourceType;
3506 0 : state->orig.out.rpc_status = _rpc_status;
3507 :
3508 : /* Result */
3509 0 : NDR_ZERO_STRUCT(state->orig.out.result);
3510 :
3511 0 : state->out_mem_ctx = talloc_named_const(state, 0,
3512 : "dcerpc_clusapi_GetResourceType_out_memory");
3513 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3514 0 : return tevent_req_post(req, ev);
3515 : }
3516 :
3517 : /* make a temporary copy, that we pass to the dispatch function */
3518 0 : state->tmp = state->orig;
3519 :
3520 0 : subreq = dcerpc_clusapi_GetResourceType_r_send(state, ev, h, &state->tmp);
3521 0 : if (tevent_req_nomem(subreq, req)) {
3522 0 : return tevent_req_post(req, ev);
3523 : }
3524 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceType_done, req);
3525 0 : return req;
3526 : }
3527 :
3528 0 : static void dcerpc_clusapi_GetResourceType_done(struct tevent_req *subreq)
3529 : {
3530 0 : struct tevent_req *req = tevent_req_callback_data(
3531 : subreq, struct tevent_req);
3532 0 : struct dcerpc_clusapi_GetResourceType_state *state = tevent_req_data(
3533 : req, struct dcerpc_clusapi_GetResourceType_state);
3534 : NTSTATUS status;
3535 : TALLOC_CTX *mem_ctx;
3536 :
3537 0 : if (state->out_mem_ctx) {
3538 0 : mem_ctx = state->out_mem_ctx;
3539 : } else {
3540 0 : mem_ctx = state;
3541 : }
3542 :
3543 0 : status = dcerpc_clusapi_GetResourceType_r_recv(subreq, mem_ctx);
3544 0 : TALLOC_FREE(subreq);
3545 0 : if (tevent_req_nterror(req, status)) {
3546 0 : return;
3547 : }
3548 :
3549 : /* Copy out parameters */
3550 0 : *state->orig.out.lpszResourceType = *state->tmp.out.lpszResourceType;
3551 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
3552 :
3553 : /* Copy result */
3554 0 : state->orig.out.result = state->tmp.out.result;
3555 :
3556 : /* Reset temporary structure */
3557 0 : NDR_ZERO_STRUCT(state->tmp);
3558 :
3559 0 : tevent_req_done(req);
3560 : }
3561 :
3562 0 : NTSTATUS dcerpc_clusapi_GetResourceType_recv(struct tevent_req *req,
3563 : TALLOC_CTX *mem_ctx,
3564 : WERROR *result)
3565 : {
3566 0 : struct dcerpc_clusapi_GetResourceType_state *state = tevent_req_data(
3567 : req, struct dcerpc_clusapi_GetResourceType_state);
3568 : NTSTATUS status;
3569 :
3570 0 : if (tevent_req_is_nterror(req, &status)) {
3571 0 : tevent_req_received(req);
3572 0 : return status;
3573 : }
3574 :
3575 : /* Steal possible out parameters to the callers context */
3576 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3577 :
3578 : /* Return result */
3579 0 : *result = state->orig.out.result;
3580 :
3581 0 : tevent_req_received(req);
3582 0 : return NT_STATUS_OK;
3583 : }
3584 :
3585 0 : NTSTATUS dcerpc_clusapi_GetResourceType(struct dcerpc_binding_handle *h,
3586 : TALLOC_CTX *mem_ctx,
3587 : struct policy_handle _hResource /* [in] */,
3588 : const char **_lpszResourceType /* [out] [charset(UTF16),ref] */,
3589 : WERROR *_rpc_status /* [out] [ref] */,
3590 : WERROR *result)
3591 : {
3592 : struct clusapi_GetResourceType r;
3593 : NTSTATUS status;
3594 :
3595 : /* In parameters */
3596 0 : r.in.hResource = _hResource;
3597 :
3598 : /* Out parameters */
3599 0 : r.out.lpszResourceType = _lpszResourceType;
3600 0 : r.out.rpc_status = _rpc_status;
3601 :
3602 : /* Result */
3603 0 : NDR_ZERO_STRUCT(r.out.result);
3604 :
3605 0 : status = dcerpc_clusapi_GetResourceType_r(h, mem_ctx, &r);
3606 0 : if (!NT_STATUS_IS_OK(status)) {
3607 0 : return status;
3608 : }
3609 :
3610 : /* Return variables */
3611 0 : *_lpszResourceType = *r.out.lpszResourceType;
3612 0 : *_rpc_status = *r.out.rpc_status;
3613 :
3614 : /* Return result */
3615 0 : *result = r.out.result;
3616 :
3617 0 : return NT_STATUS_OK;
3618 : }
3619 :
3620 : struct dcerpc_clusapi_FailResource_r_state {
3621 : TALLOC_CTX *out_mem_ctx;
3622 : };
3623 :
3624 : static void dcerpc_clusapi_FailResource_r_done(struct tevent_req *subreq);
3625 :
3626 0 : struct tevent_req *dcerpc_clusapi_FailResource_r_send(TALLOC_CTX *mem_ctx,
3627 : struct tevent_context *ev,
3628 : struct dcerpc_binding_handle *h,
3629 : struct clusapi_FailResource *r)
3630 : {
3631 : struct tevent_req *req;
3632 : struct dcerpc_clusapi_FailResource_r_state *state;
3633 : struct tevent_req *subreq;
3634 :
3635 0 : req = tevent_req_create(mem_ctx, &state,
3636 : struct dcerpc_clusapi_FailResource_r_state);
3637 0 : if (req == NULL) {
3638 0 : return NULL;
3639 : }
3640 :
3641 0 : state->out_mem_ctx = talloc_new(state);
3642 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3643 0 : return tevent_req_post(req, ev);
3644 : }
3645 :
3646 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
3647 : NULL, &ndr_table_clusapi,
3648 0 : NDR_CLUSAPI_FAILRESOURCE, state->out_mem_ctx, r);
3649 0 : if (tevent_req_nomem(subreq, req)) {
3650 0 : return tevent_req_post(req, ev);
3651 : }
3652 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_FailResource_r_done, req);
3653 :
3654 0 : return req;
3655 : }
3656 :
3657 0 : static void dcerpc_clusapi_FailResource_r_done(struct tevent_req *subreq)
3658 : {
3659 0 : struct tevent_req *req =
3660 0 : tevent_req_callback_data(subreq,
3661 : struct tevent_req);
3662 : NTSTATUS status;
3663 :
3664 0 : status = dcerpc_binding_handle_call_recv(subreq);
3665 0 : TALLOC_FREE(subreq);
3666 0 : if (tevent_req_nterror(req, status)) {
3667 0 : return;
3668 : }
3669 :
3670 0 : tevent_req_done(req);
3671 : }
3672 :
3673 0 : NTSTATUS dcerpc_clusapi_FailResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3674 : {
3675 0 : struct dcerpc_clusapi_FailResource_r_state *state =
3676 0 : tevent_req_data(req,
3677 : struct dcerpc_clusapi_FailResource_r_state);
3678 : NTSTATUS status;
3679 :
3680 0 : if (tevent_req_is_nterror(req, &status)) {
3681 0 : tevent_req_received(req);
3682 0 : return status;
3683 : }
3684 :
3685 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3686 :
3687 0 : tevent_req_received(req);
3688 0 : return NT_STATUS_OK;
3689 : }
3690 :
3691 0 : NTSTATUS dcerpc_clusapi_FailResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_FailResource *r)
3692 : {
3693 : NTSTATUS status;
3694 :
3695 0 : status = dcerpc_binding_handle_call(h,
3696 : NULL, &ndr_table_clusapi,
3697 : NDR_CLUSAPI_FAILRESOURCE, mem_ctx, r);
3698 :
3699 0 : return status;
3700 : }
3701 :
3702 : struct dcerpc_clusapi_FailResource_state {
3703 : struct clusapi_FailResource orig;
3704 : struct clusapi_FailResource tmp;
3705 : TALLOC_CTX *out_mem_ctx;
3706 : };
3707 :
3708 : static void dcerpc_clusapi_FailResource_done(struct tevent_req *subreq);
3709 :
3710 0 : struct tevent_req *dcerpc_clusapi_FailResource_send(TALLOC_CTX *mem_ctx,
3711 : struct tevent_context *ev,
3712 : struct dcerpc_binding_handle *h,
3713 : struct policy_handle _hResource /* [in] */,
3714 : WERROR *_rpc_status /* [out] [ref] */)
3715 : {
3716 : struct tevent_req *req;
3717 : struct dcerpc_clusapi_FailResource_state *state;
3718 : struct tevent_req *subreq;
3719 :
3720 0 : req = tevent_req_create(mem_ctx, &state,
3721 : struct dcerpc_clusapi_FailResource_state);
3722 0 : if (req == NULL) {
3723 0 : return NULL;
3724 : }
3725 0 : state->out_mem_ctx = NULL;
3726 :
3727 : /* In parameters */
3728 0 : state->orig.in.hResource = _hResource;
3729 :
3730 : /* Out parameters */
3731 0 : state->orig.out.rpc_status = _rpc_status;
3732 :
3733 : /* Result */
3734 0 : NDR_ZERO_STRUCT(state->orig.out.result);
3735 :
3736 0 : state->out_mem_ctx = talloc_named_const(state, 0,
3737 : "dcerpc_clusapi_FailResource_out_memory");
3738 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3739 0 : return tevent_req_post(req, ev);
3740 : }
3741 :
3742 : /* make a temporary copy, that we pass to the dispatch function */
3743 0 : state->tmp = state->orig;
3744 :
3745 0 : subreq = dcerpc_clusapi_FailResource_r_send(state, ev, h, &state->tmp);
3746 0 : if (tevent_req_nomem(subreq, req)) {
3747 0 : return tevent_req_post(req, ev);
3748 : }
3749 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_FailResource_done, req);
3750 0 : return req;
3751 : }
3752 :
3753 0 : static void dcerpc_clusapi_FailResource_done(struct tevent_req *subreq)
3754 : {
3755 0 : struct tevent_req *req = tevent_req_callback_data(
3756 : subreq, struct tevent_req);
3757 0 : struct dcerpc_clusapi_FailResource_state *state = tevent_req_data(
3758 : req, struct dcerpc_clusapi_FailResource_state);
3759 : NTSTATUS status;
3760 : TALLOC_CTX *mem_ctx;
3761 :
3762 0 : if (state->out_mem_ctx) {
3763 0 : mem_ctx = state->out_mem_ctx;
3764 : } else {
3765 0 : mem_ctx = state;
3766 : }
3767 :
3768 0 : status = dcerpc_clusapi_FailResource_r_recv(subreq, mem_ctx);
3769 0 : TALLOC_FREE(subreq);
3770 0 : if (tevent_req_nterror(req, status)) {
3771 0 : return;
3772 : }
3773 :
3774 : /* Copy out parameters */
3775 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
3776 :
3777 : /* Copy result */
3778 0 : state->orig.out.result = state->tmp.out.result;
3779 :
3780 : /* Reset temporary structure */
3781 0 : NDR_ZERO_STRUCT(state->tmp);
3782 :
3783 0 : tevent_req_done(req);
3784 : }
3785 :
3786 0 : NTSTATUS dcerpc_clusapi_FailResource_recv(struct tevent_req *req,
3787 : TALLOC_CTX *mem_ctx,
3788 : WERROR *result)
3789 : {
3790 0 : struct dcerpc_clusapi_FailResource_state *state = tevent_req_data(
3791 : req, struct dcerpc_clusapi_FailResource_state);
3792 : NTSTATUS status;
3793 :
3794 0 : if (tevent_req_is_nterror(req, &status)) {
3795 0 : tevent_req_received(req);
3796 0 : return status;
3797 : }
3798 :
3799 : /* Steal possible out parameters to the callers context */
3800 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3801 :
3802 : /* Return result */
3803 0 : *result = state->orig.out.result;
3804 :
3805 0 : tevent_req_received(req);
3806 0 : return NT_STATUS_OK;
3807 : }
3808 :
3809 0 : NTSTATUS dcerpc_clusapi_FailResource(struct dcerpc_binding_handle *h,
3810 : TALLOC_CTX *mem_ctx,
3811 : struct policy_handle _hResource /* [in] */,
3812 : WERROR *_rpc_status /* [out] [ref] */,
3813 : WERROR *result)
3814 : {
3815 : struct clusapi_FailResource r;
3816 : NTSTATUS status;
3817 :
3818 : /* In parameters */
3819 0 : r.in.hResource = _hResource;
3820 :
3821 : /* Out parameters */
3822 0 : r.out.rpc_status = _rpc_status;
3823 :
3824 : /* Result */
3825 0 : NDR_ZERO_STRUCT(r.out.result);
3826 :
3827 0 : status = dcerpc_clusapi_FailResource_r(h, mem_ctx, &r);
3828 0 : if (!NT_STATUS_IS_OK(status)) {
3829 0 : return status;
3830 : }
3831 :
3832 : /* Return variables */
3833 0 : *_rpc_status = *r.out.rpc_status;
3834 :
3835 : /* Return result */
3836 0 : *result = r.out.result;
3837 :
3838 0 : return NT_STATUS_OK;
3839 : }
3840 :
3841 : struct dcerpc_clusapi_OnlineResource_r_state {
3842 : TALLOC_CTX *out_mem_ctx;
3843 : };
3844 :
3845 : static void dcerpc_clusapi_OnlineResource_r_done(struct tevent_req *subreq);
3846 :
3847 0 : struct tevent_req *dcerpc_clusapi_OnlineResource_r_send(TALLOC_CTX *mem_ctx,
3848 : struct tevent_context *ev,
3849 : struct dcerpc_binding_handle *h,
3850 : struct clusapi_OnlineResource *r)
3851 : {
3852 : struct tevent_req *req;
3853 : struct dcerpc_clusapi_OnlineResource_r_state *state;
3854 : struct tevent_req *subreq;
3855 :
3856 0 : req = tevent_req_create(mem_ctx, &state,
3857 : struct dcerpc_clusapi_OnlineResource_r_state);
3858 0 : if (req == NULL) {
3859 0 : return NULL;
3860 : }
3861 :
3862 0 : state->out_mem_ctx = talloc_new(state);
3863 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3864 0 : return tevent_req_post(req, ev);
3865 : }
3866 :
3867 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
3868 : NULL, &ndr_table_clusapi,
3869 0 : NDR_CLUSAPI_ONLINERESOURCE, state->out_mem_ctx, r);
3870 0 : if (tevent_req_nomem(subreq, req)) {
3871 0 : return tevent_req_post(req, ev);
3872 : }
3873 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineResource_r_done, req);
3874 :
3875 0 : return req;
3876 : }
3877 :
3878 0 : static void dcerpc_clusapi_OnlineResource_r_done(struct tevent_req *subreq)
3879 : {
3880 0 : struct tevent_req *req =
3881 0 : tevent_req_callback_data(subreq,
3882 : struct tevent_req);
3883 : NTSTATUS status;
3884 :
3885 0 : status = dcerpc_binding_handle_call_recv(subreq);
3886 0 : TALLOC_FREE(subreq);
3887 0 : if (tevent_req_nterror(req, status)) {
3888 0 : return;
3889 : }
3890 :
3891 0 : tevent_req_done(req);
3892 : }
3893 :
3894 0 : NTSTATUS dcerpc_clusapi_OnlineResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3895 : {
3896 0 : struct dcerpc_clusapi_OnlineResource_r_state *state =
3897 0 : tevent_req_data(req,
3898 : struct dcerpc_clusapi_OnlineResource_r_state);
3899 : NTSTATUS status;
3900 :
3901 0 : if (tevent_req_is_nterror(req, &status)) {
3902 0 : tevent_req_received(req);
3903 0 : return status;
3904 : }
3905 :
3906 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
3907 :
3908 0 : tevent_req_received(req);
3909 0 : return NT_STATUS_OK;
3910 : }
3911 :
3912 0 : NTSTATUS dcerpc_clusapi_OnlineResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OnlineResource *r)
3913 : {
3914 : NTSTATUS status;
3915 :
3916 0 : status = dcerpc_binding_handle_call(h,
3917 : NULL, &ndr_table_clusapi,
3918 : NDR_CLUSAPI_ONLINERESOURCE, mem_ctx, r);
3919 :
3920 0 : return status;
3921 : }
3922 :
3923 : struct dcerpc_clusapi_OnlineResource_state {
3924 : struct clusapi_OnlineResource orig;
3925 : struct clusapi_OnlineResource tmp;
3926 : TALLOC_CTX *out_mem_ctx;
3927 : };
3928 :
3929 : static void dcerpc_clusapi_OnlineResource_done(struct tevent_req *subreq);
3930 :
3931 0 : struct tevent_req *dcerpc_clusapi_OnlineResource_send(TALLOC_CTX *mem_ctx,
3932 : struct tevent_context *ev,
3933 : struct dcerpc_binding_handle *h,
3934 : struct policy_handle _hResource /* [in] */,
3935 : WERROR *_rpc_status /* [out] [ref] */)
3936 : {
3937 : struct tevent_req *req;
3938 : struct dcerpc_clusapi_OnlineResource_state *state;
3939 : struct tevent_req *subreq;
3940 :
3941 0 : req = tevent_req_create(mem_ctx, &state,
3942 : struct dcerpc_clusapi_OnlineResource_state);
3943 0 : if (req == NULL) {
3944 0 : return NULL;
3945 : }
3946 0 : state->out_mem_ctx = NULL;
3947 :
3948 : /* In parameters */
3949 0 : state->orig.in.hResource = _hResource;
3950 :
3951 : /* Out parameters */
3952 0 : state->orig.out.rpc_status = _rpc_status;
3953 :
3954 : /* Result */
3955 0 : NDR_ZERO_STRUCT(state->orig.out.result);
3956 :
3957 0 : state->out_mem_ctx = talloc_named_const(state, 0,
3958 : "dcerpc_clusapi_OnlineResource_out_memory");
3959 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
3960 0 : return tevent_req_post(req, ev);
3961 : }
3962 :
3963 : /* make a temporary copy, that we pass to the dispatch function */
3964 0 : state->tmp = state->orig;
3965 :
3966 0 : subreq = dcerpc_clusapi_OnlineResource_r_send(state, ev, h, &state->tmp);
3967 0 : if (tevent_req_nomem(subreq, req)) {
3968 0 : return tevent_req_post(req, ev);
3969 : }
3970 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineResource_done, req);
3971 0 : return req;
3972 : }
3973 :
3974 0 : static void dcerpc_clusapi_OnlineResource_done(struct tevent_req *subreq)
3975 : {
3976 0 : struct tevent_req *req = tevent_req_callback_data(
3977 : subreq, struct tevent_req);
3978 0 : struct dcerpc_clusapi_OnlineResource_state *state = tevent_req_data(
3979 : req, struct dcerpc_clusapi_OnlineResource_state);
3980 : NTSTATUS status;
3981 : TALLOC_CTX *mem_ctx;
3982 :
3983 0 : if (state->out_mem_ctx) {
3984 0 : mem_ctx = state->out_mem_ctx;
3985 : } else {
3986 0 : mem_ctx = state;
3987 : }
3988 :
3989 0 : status = dcerpc_clusapi_OnlineResource_r_recv(subreq, mem_ctx);
3990 0 : TALLOC_FREE(subreq);
3991 0 : if (tevent_req_nterror(req, status)) {
3992 0 : return;
3993 : }
3994 :
3995 : /* Copy out parameters */
3996 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
3997 :
3998 : /* Copy result */
3999 0 : state->orig.out.result = state->tmp.out.result;
4000 :
4001 : /* Reset temporary structure */
4002 0 : NDR_ZERO_STRUCT(state->tmp);
4003 :
4004 0 : tevent_req_done(req);
4005 : }
4006 :
4007 0 : NTSTATUS dcerpc_clusapi_OnlineResource_recv(struct tevent_req *req,
4008 : TALLOC_CTX *mem_ctx,
4009 : WERROR *result)
4010 : {
4011 0 : struct dcerpc_clusapi_OnlineResource_state *state = tevent_req_data(
4012 : req, struct dcerpc_clusapi_OnlineResource_state);
4013 : NTSTATUS status;
4014 :
4015 0 : if (tevent_req_is_nterror(req, &status)) {
4016 0 : tevent_req_received(req);
4017 0 : return status;
4018 : }
4019 :
4020 : /* Steal possible out parameters to the callers context */
4021 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4022 :
4023 : /* Return result */
4024 0 : *result = state->orig.out.result;
4025 :
4026 0 : tevent_req_received(req);
4027 0 : return NT_STATUS_OK;
4028 : }
4029 :
4030 0 : NTSTATUS dcerpc_clusapi_OnlineResource(struct dcerpc_binding_handle *h,
4031 : TALLOC_CTX *mem_ctx,
4032 : struct policy_handle _hResource /* [in] */,
4033 : WERROR *_rpc_status /* [out] [ref] */,
4034 : WERROR *result)
4035 : {
4036 : struct clusapi_OnlineResource r;
4037 : NTSTATUS status;
4038 :
4039 : /* In parameters */
4040 0 : r.in.hResource = _hResource;
4041 :
4042 : /* Out parameters */
4043 0 : r.out.rpc_status = _rpc_status;
4044 :
4045 : /* Result */
4046 0 : NDR_ZERO_STRUCT(r.out.result);
4047 :
4048 0 : status = dcerpc_clusapi_OnlineResource_r(h, mem_ctx, &r);
4049 0 : if (!NT_STATUS_IS_OK(status)) {
4050 0 : return status;
4051 : }
4052 :
4053 : /* Return variables */
4054 0 : *_rpc_status = *r.out.rpc_status;
4055 :
4056 : /* Return result */
4057 0 : *result = r.out.result;
4058 :
4059 0 : return NT_STATUS_OK;
4060 : }
4061 :
4062 : struct dcerpc_clusapi_OfflineResource_r_state {
4063 : TALLOC_CTX *out_mem_ctx;
4064 : };
4065 :
4066 : static void dcerpc_clusapi_OfflineResource_r_done(struct tevent_req *subreq);
4067 :
4068 0 : struct tevent_req *dcerpc_clusapi_OfflineResource_r_send(TALLOC_CTX *mem_ctx,
4069 : struct tevent_context *ev,
4070 : struct dcerpc_binding_handle *h,
4071 : struct clusapi_OfflineResource *r)
4072 : {
4073 : struct tevent_req *req;
4074 : struct dcerpc_clusapi_OfflineResource_r_state *state;
4075 : struct tevent_req *subreq;
4076 :
4077 0 : req = tevent_req_create(mem_ctx, &state,
4078 : struct dcerpc_clusapi_OfflineResource_r_state);
4079 0 : if (req == NULL) {
4080 0 : return NULL;
4081 : }
4082 :
4083 0 : state->out_mem_ctx = talloc_new(state);
4084 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4085 0 : return tevent_req_post(req, ev);
4086 : }
4087 :
4088 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
4089 : NULL, &ndr_table_clusapi,
4090 0 : NDR_CLUSAPI_OFFLINERESOURCE, state->out_mem_ctx, r);
4091 0 : if (tevent_req_nomem(subreq, req)) {
4092 0 : return tevent_req_post(req, ev);
4093 : }
4094 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineResource_r_done, req);
4095 :
4096 0 : return req;
4097 : }
4098 :
4099 0 : static void dcerpc_clusapi_OfflineResource_r_done(struct tevent_req *subreq)
4100 : {
4101 0 : struct tevent_req *req =
4102 0 : tevent_req_callback_data(subreq,
4103 : struct tevent_req);
4104 : NTSTATUS status;
4105 :
4106 0 : status = dcerpc_binding_handle_call_recv(subreq);
4107 0 : TALLOC_FREE(subreq);
4108 0 : if (tevent_req_nterror(req, status)) {
4109 0 : return;
4110 : }
4111 :
4112 0 : tevent_req_done(req);
4113 : }
4114 :
4115 0 : NTSTATUS dcerpc_clusapi_OfflineResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4116 : {
4117 0 : struct dcerpc_clusapi_OfflineResource_r_state *state =
4118 0 : tevent_req_data(req,
4119 : struct dcerpc_clusapi_OfflineResource_r_state);
4120 : NTSTATUS status;
4121 :
4122 0 : if (tevent_req_is_nterror(req, &status)) {
4123 0 : tevent_req_received(req);
4124 0 : return status;
4125 : }
4126 :
4127 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4128 :
4129 0 : tevent_req_received(req);
4130 0 : return NT_STATUS_OK;
4131 : }
4132 :
4133 0 : NTSTATUS dcerpc_clusapi_OfflineResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OfflineResource *r)
4134 : {
4135 : NTSTATUS status;
4136 :
4137 0 : status = dcerpc_binding_handle_call(h,
4138 : NULL, &ndr_table_clusapi,
4139 : NDR_CLUSAPI_OFFLINERESOURCE, mem_ctx, r);
4140 :
4141 0 : return status;
4142 : }
4143 :
4144 : struct dcerpc_clusapi_OfflineResource_state {
4145 : struct clusapi_OfflineResource orig;
4146 : struct clusapi_OfflineResource tmp;
4147 : TALLOC_CTX *out_mem_ctx;
4148 : };
4149 :
4150 : static void dcerpc_clusapi_OfflineResource_done(struct tevent_req *subreq);
4151 :
4152 0 : struct tevent_req *dcerpc_clusapi_OfflineResource_send(TALLOC_CTX *mem_ctx,
4153 : struct tevent_context *ev,
4154 : struct dcerpc_binding_handle *h,
4155 : struct policy_handle _hResource /* [in] */,
4156 : WERROR *_rpc_status /* [out] [ref] */)
4157 : {
4158 : struct tevent_req *req;
4159 : struct dcerpc_clusapi_OfflineResource_state *state;
4160 : struct tevent_req *subreq;
4161 :
4162 0 : req = tevent_req_create(mem_ctx, &state,
4163 : struct dcerpc_clusapi_OfflineResource_state);
4164 0 : if (req == NULL) {
4165 0 : return NULL;
4166 : }
4167 0 : state->out_mem_ctx = NULL;
4168 :
4169 : /* In parameters */
4170 0 : state->orig.in.hResource = _hResource;
4171 :
4172 : /* Out parameters */
4173 0 : state->orig.out.rpc_status = _rpc_status;
4174 :
4175 : /* Result */
4176 0 : NDR_ZERO_STRUCT(state->orig.out.result);
4177 :
4178 0 : state->out_mem_ctx = talloc_named_const(state, 0,
4179 : "dcerpc_clusapi_OfflineResource_out_memory");
4180 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4181 0 : return tevent_req_post(req, ev);
4182 : }
4183 :
4184 : /* make a temporary copy, that we pass to the dispatch function */
4185 0 : state->tmp = state->orig;
4186 :
4187 0 : subreq = dcerpc_clusapi_OfflineResource_r_send(state, ev, h, &state->tmp);
4188 0 : if (tevent_req_nomem(subreq, req)) {
4189 0 : return tevent_req_post(req, ev);
4190 : }
4191 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineResource_done, req);
4192 0 : return req;
4193 : }
4194 :
4195 0 : static void dcerpc_clusapi_OfflineResource_done(struct tevent_req *subreq)
4196 : {
4197 0 : struct tevent_req *req = tevent_req_callback_data(
4198 : subreq, struct tevent_req);
4199 0 : struct dcerpc_clusapi_OfflineResource_state *state = tevent_req_data(
4200 : req, struct dcerpc_clusapi_OfflineResource_state);
4201 : NTSTATUS status;
4202 : TALLOC_CTX *mem_ctx;
4203 :
4204 0 : if (state->out_mem_ctx) {
4205 0 : mem_ctx = state->out_mem_ctx;
4206 : } else {
4207 0 : mem_ctx = state;
4208 : }
4209 :
4210 0 : status = dcerpc_clusapi_OfflineResource_r_recv(subreq, mem_ctx);
4211 0 : TALLOC_FREE(subreq);
4212 0 : if (tevent_req_nterror(req, status)) {
4213 0 : return;
4214 : }
4215 :
4216 : /* Copy out parameters */
4217 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
4218 :
4219 : /* Copy result */
4220 0 : state->orig.out.result = state->tmp.out.result;
4221 :
4222 : /* Reset temporary structure */
4223 0 : NDR_ZERO_STRUCT(state->tmp);
4224 :
4225 0 : tevent_req_done(req);
4226 : }
4227 :
4228 0 : NTSTATUS dcerpc_clusapi_OfflineResource_recv(struct tevent_req *req,
4229 : TALLOC_CTX *mem_ctx,
4230 : WERROR *result)
4231 : {
4232 0 : struct dcerpc_clusapi_OfflineResource_state *state = tevent_req_data(
4233 : req, struct dcerpc_clusapi_OfflineResource_state);
4234 : NTSTATUS status;
4235 :
4236 0 : if (tevent_req_is_nterror(req, &status)) {
4237 0 : tevent_req_received(req);
4238 0 : return status;
4239 : }
4240 :
4241 : /* Steal possible out parameters to the callers context */
4242 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4243 :
4244 : /* Return result */
4245 0 : *result = state->orig.out.result;
4246 :
4247 0 : tevent_req_received(req);
4248 0 : return NT_STATUS_OK;
4249 : }
4250 :
4251 0 : NTSTATUS dcerpc_clusapi_OfflineResource(struct dcerpc_binding_handle *h,
4252 : TALLOC_CTX *mem_ctx,
4253 : struct policy_handle _hResource /* [in] */,
4254 : WERROR *_rpc_status /* [out] [ref] */,
4255 : WERROR *result)
4256 : {
4257 : struct clusapi_OfflineResource r;
4258 : NTSTATUS status;
4259 :
4260 : /* In parameters */
4261 0 : r.in.hResource = _hResource;
4262 :
4263 : /* Out parameters */
4264 0 : r.out.rpc_status = _rpc_status;
4265 :
4266 : /* Result */
4267 0 : NDR_ZERO_STRUCT(r.out.result);
4268 :
4269 0 : status = dcerpc_clusapi_OfflineResource_r(h, mem_ctx, &r);
4270 0 : if (!NT_STATUS_IS_OK(status)) {
4271 0 : return status;
4272 : }
4273 :
4274 : /* Return variables */
4275 0 : *_rpc_status = *r.out.rpc_status;
4276 :
4277 : /* Return result */
4278 0 : *result = r.out.result;
4279 :
4280 0 : return NT_STATUS_OK;
4281 : }
4282 :
4283 : struct dcerpc_clusapi_AddResourceDependency_r_state {
4284 : TALLOC_CTX *out_mem_ctx;
4285 : };
4286 :
4287 : static void dcerpc_clusapi_AddResourceDependency_r_done(struct tevent_req *subreq);
4288 :
4289 0 : struct tevent_req *dcerpc_clusapi_AddResourceDependency_r_send(TALLOC_CTX *mem_ctx,
4290 : struct tevent_context *ev,
4291 : struct dcerpc_binding_handle *h,
4292 : struct clusapi_AddResourceDependency *r)
4293 : {
4294 : struct tevent_req *req;
4295 : struct dcerpc_clusapi_AddResourceDependency_r_state *state;
4296 : struct tevent_req *subreq;
4297 :
4298 0 : req = tevent_req_create(mem_ctx, &state,
4299 : struct dcerpc_clusapi_AddResourceDependency_r_state);
4300 0 : if (req == NULL) {
4301 0 : return NULL;
4302 : }
4303 :
4304 0 : state->out_mem_ctx = talloc_new(state);
4305 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4306 0 : return tevent_req_post(req, ev);
4307 : }
4308 :
4309 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
4310 : NULL, &ndr_table_clusapi,
4311 0 : NDR_CLUSAPI_ADDRESOURCEDEPENDENCY, state->out_mem_ctx, r);
4312 0 : if (tevent_req_nomem(subreq, req)) {
4313 0 : return tevent_req_post(req, ev);
4314 : }
4315 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddResourceDependency_r_done, req);
4316 :
4317 0 : return req;
4318 : }
4319 :
4320 0 : static void dcerpc_clusapi_AddResourceDependency_r_done(struct tevent_req *subreq)
4321 : {
4322 0 : struct tevent_req *req =
4323 0 : tevent_req_callback_data(subreq,
4324 : struct tevent_req);
4325 : NTSTATUS status;
4326 :
4327 0 : status = dcerpc_binding_handle_call_recv(subreq);
4328 0 : TALLOC_FREE(subreq);
4329 0 : if (tevent_req_nterror(req, status)) {
4330 0 : return;
4331 : }
4332 :
4333 0 : tevent_req_done(req);
4334 : }
4335 :
4336 0 : NTSTATUS dcerpc_clusapi_AddResourceDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4337 : {
4338 0 : struct dcerpc_clusapi_AddResourceDependency_r_state *state =
4339 0 : tevent_req_data(req,
4340 : struct dcerpc_clusapi_AddResourceDependency_r_state);
4341 : NTSTATUS status;
4342 :
4343 0 : if (tevent_req_is_nterror(req, &status)) {
4344 0 : tevent_req_received(req);
4345 0 : return status;
4346 : }
4347 :
4348 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4349 :
4350 0 : tevent_req_received(req);
4351 0 : return NT_STATUS_OK;
4352 : }
4353 :
4354 0 : NTSTATUS dcerpc_clusapi_AddResourceDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddResourceDependency *r)
4355 : {
4356 : NTSTATUS status;
4357 :
4358 0 : status = dcerpc_binding_handle_call(h,
4359 : NULL, &ndr_table_clusapi,
4360 : NDR_CLUSAPI_ADDRESOURCEDEPENDENCY, mem_ctx, r);
4361 :
4362 0 : return status;
4363 : }
4364 :
4365 : struct dcerpc_clusapi_AddResourceDependency_state {
4366 : struct clusapi_AddResourceDependency orig;
4367 : struct clusapi_AddResourceDependency tmp;
4368 : TALLOC_CTX *out_mem_ctx;
4369 : };
4370 :
4371 : static void dcerpc_clusapi_AddResourceDependency_done(struct tevent_req *subreq);
4372 :
4373 0 : struct tevent_req *dcerpc_clusapi_AddResourceDependency_send(TALLOC_CTX *mem_ctx,
4374 : struct tevent_context *ev,
4375 : struct dcerpc_binding_handle *h,
4376 : struct policy_handle _hResource /* [in] */,
4377 : struct policy_handle _hDependsOn /* [in] */,
4378 : WERROR *_rpc_status /* [out] [ref] */)
4379 : {
4380 : struct tevent_req *req;
4381 : struct dcerpc_clusapi_AddResourceDependency_state *state;
4382 : struct tevent_req *subreq;
4383 :
4384 0 : req = tevent_req_create(mem_ctx, &state,
4385 : struct dcerpc_clusapi_AddResourceDependency_state);
4386 0 : if (req == NULL) {
4387 0 : return NULL;
4388 : }
4389 0 : state->out_mem_ctx = NULL;
4390 :
4391 : /* In parameters */
4392 0 : state->orig.in.hResource = _hResource;
4393 0 : state->orig.in.hDependsOn = _hDependsOn;
4394 :
4395 : /* Out parameters */
4396 0 : state->orig.out.rpc_status = _rpc_status;
4397 :
4398 : /* Result */
4399 0 : NDR_ZERO_STRUCT(state->orig.out.result);
4400 :
4401 0 : state->out_mem_ctx = talloc_named_const(state, 0,
4402 : "dcerpc_clusapi_AddResourceDependency_out_memory");
4403 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4404 0 : return tevent_req_post(req, ev);
4405 : }
4406 :
4407 : /* make a temporary copy, that we pass to the dispatch function */
4408 0 : state->tmp = state->orig;
4409 :
4410 0 : subreq = dcerpc_clusapi_AddResourceDependency_r_send(state, ev, h, &state->tmp);
4411 0 : if (tevent_req_nomem(subreq, req)) {
4412 0 : return tevent_req_post(req, ev);
4413 : }
4414 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddResourceDependency_done, req);
4415 0 : return req;
4416 : }
4417 :
4418 0 : static void dcerpc_clusapi_AddResourceDependency_done(struct tevent_req *subreq)
4419 : {
4420 0 : struct tevent_req *req = tevent_req_callback_data(
4421 : subreq, struct tevent_req);
4422 0 : struct dcerpc_clusapi_AddResourceDependency_state *state = tevent_req_data(
4423 : req, struct dcerpc_clusapi_AddResourceDependency_state);
4424 : NTSTATUS status;
4425 : TALLOC_CTX *mem_ctx;
4426 :
4427 0 : if (state->out_mem_ctx) {
4428 0 : mem_ctx = state->out_mem_ctx;
4429 : } else {
4430 0 : mem_ctx = state;
4431 : }
4432 :
4433 0 : status = dcerpc_clusapi_AddResourceDependency_r_recv(subreq, mem_ctx);
4434 0 : TALLOC_FREE(subreq);
4435 0 : if (tevent_req_nterror(req, status)) {
4436 0 : return;
4437 : }
4438 :
4439 : /* Copy out parameters */
4440 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
4441 :
4442 : /* Copy result */
4443 0 : state->orig.out.result = state->tmp.out.result;
4444 :
4445 : /* Reset temporary structure */
4446 0 : NDR_ZERO_STRUCT(state->tmp);
4447 :
4448 0 : tevent_req_done(req);
4449 : }
4450 :
4451 0 : NTSTATUS dcerpc_clusapi_AddResourceDependency_recv(struct tevent_req *req,
4452 : TALLOC_CTX *mem_ctx,
4453 : WERROR *result)
4454 : {
4455 0 : struct dcerpc_clusapi_AddResourceDependency_state *state = tevent_req_data(
4456 : req, struct dcerpc_clusapi_AddResourceDependency_state);
4457 : NTSTATUS status;
4458 :
4459 0 : if (tevent_req_is_nterror(req, &status)) {
4460 0 : tevent_req_received(req);
4461 0 : return status;
4462 : }
4463 :
4464 : /* Steal possible out parameters to the callers context */
4465 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4466 :
4467 : /* Return result */
4468 0 : *result = state->orig.out.result;
4469 :
4470 0 : tevent_req_received(req);
4471 0 : return NT_STATUS_OK;
4472 : }
4473 :
4474 0 : NTSTATUS dcerpc_clusapi_AddResourceDependency(struct dcerpc_binding_handle *h,
4475 : TALLOC_CTX *mem_ctx,
4476 : struct policy_handle _hResource /* [in] */,
4477 : struct policy_handle _hDependsOn /* [in] */,
4478 : WERROR *_rpc_status /* [out] [ref] */,
4479 : WERROR *result)
4480 : {
4481 : struct clusapi_AddResourceDependency r;
4482 : NTSTATUS status;
4483 :
4484 : /* In parameters */
4485 0 : r.in.hResource = _hResource;
4486 0 : r.in.hDependsOn = _hDependsOn;
4487 :
4488 : /* Out parameters */
4489 0 : r.out.rpc_status = _rpc_status;
4490 :
4491 : /* Result */
4492 0 : NDR_ZERO_STRUCT(r.out.result);
4493 :
4494 0 : status = dcerpc_clusapi_AddResourceDependency_r(h, mem_ctx, &r);
4495 0 : if (!NT_STATUS_IS_OK(status)) {
4496 0 : return status;
4497 : }
4498 :
4499 : /* Return variables */
4500 0 : *_rpc_status = *r.out.rpc_status;
4501 :
4502 : /* Return result */
4503 0 : *result = r.out.result;
4504 :
4505 0 : return NT_STATUS_OK;
4506 : }
4507 :
4508 : struct dcerpc_clusapi_RemoveResourceDependency_r_state {
4509 : TALLOC_CTX *out_mem_ctx;
4510 : };
4511 :
4512 : static void dcerpc_clusapi_RemoveResourceDependency_r_done(struct tevent_req *subreq);
4513 :
4514 0 : struct tevent_req *dcerpc_clusapi_RemoveResourceDependency_r_send(TALLOC_CTX *mem_ctx,
4515 : struct tevent_context *ev,
4516 : struct dcerpc_binding_handle *h,
4517 : struct clusapi_RemoveResourceDependency *r)
4518 : {
4519 : struct tevent_req *req;
4520 : struct dcerpc_clusapi_RemoveResourceDependency_r_state *state;
4521 : struct tevent_req *subreq;
4522 :
4523 0 : req = tevent_req_create(mem_ctx, &state,
4524 : struct dcerpc_clusapi_RemoveResourceDependency_r_state);
4525 0 : if (req == NULL) {
4526 0 : return NULL;
4527 : }
4528 :
4529 0 : state->out_mem_ctx = talloc_new(state);
4530 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4531 0 : return tevent_req_post(req, ev);
4532 : }
4533 :
4534 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
4535 : NULL, &ndr_table_clusapi,
4536 0 : NDR_CLUSAPI_REMOVERESOURCEDEPENDENCY, state->out_mem_ctx, r);
4537 0 : if (tevent_req_nomem(subreq, req)) {
4538 0 : return tevent_req_post(req, ev);
4539 : }
4540 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveResourceDependency_r_done, req);
4541 :
4542 0 : return req;
4543 : }
4544 :
4545 0 : static void dcerpc_clusapi_RemoveResourceDependency_r_done(struct tevent_req *subreq)
4546 : {
4547 0 : struct tevent_req *req =
4548 0 : tevent_req_callback_data(subreq,
4549 : struct tevent_req);
4550 : NTSTATUS status;
4551 :
4552 0 : status = dcerpc_binding_handle_call_recv(subreq);
4553 0 : TALLOC_FREE(subreq);
4554 0 : if (tevent_req_nterror(req, status)) {
4555 0 : return;
4556 : }
4557 :
4558 0 : tevent_req_done(req);
4559 : }
4560 :
4561 0 : NTSTATUS dcerpc_clusapi_RemoveResourceDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4562 : {
4563 0 : struct dcerpc_clusapi_RemoveResourceDependency_r_state *state =
4564 0 : tevent_req_data(req,
4565 : struct dcerpc_clusapi_RemoveResourceDependency_r_state);
4566 : NTSTATUS status;
4567 :
4568 0 : if (tevent_req_is_nterror(req, &status)) {
4569 0 : tevent_req_received(req);
4570 0 : return status;
4571 : }
4572 :
4573 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4574 :
4575 0 : tevent_req_received(req);
4576 0 : return NT_STATUS_OK;
4577 : }
4578 :
4579 0 : NTSTATUS dcerpc_clusapi_RemoveResourceDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveResourceDependency *r)
4580 : {
4581 : NTSTATUS status;
4582 :
4583 0 : status = dcerpc_binding_handle_call(h,
4584 : NULL, &ndr_table_clusapi,
4585 : NDR_CLUSAPI_REMOVERESOURCEDEPENDENCY, mem_ctx, r);
4586 :
4587 0 : return status;
4588 : }
4589 :
4590 : struct dcerpc_clusapi_RemoveResourceDependency_state {
4591 : struct clusapi_RemoveResourceDependency orig;
4592 : struct clusapi_RemoveResourceDependency tmp;
4593 : TALLOC_CTX *out_mem_ctx;
4594 : };
4595 :
4596 : static void dcerpc_clusapi_RemoveResourceDependency_done(struct tevent_req *subreq);
4597 :
4598 0 : struct tevent_req *dcerpc_clusapi_RemoveResourceDependency_send(TALLOC_CTX *mem_ctx,
4599 : struct tevent_context *ev,
4600 : struct dcerpc_binding_handle *h,
4601 : struct policy_handle _hResource /* [in] */,
4602 : struct policy_handle _hDependsOn /* [in] */,
4603 : WERROR *_rpc_status /* [out] [ref] */)
4604 : {
4605 : struct tevent_req *req;
4606 : struct dcerpc_clusapi_RemoveResourceDependency_state *state;
4607 : struct tevent_req *subreq;
4608 :
4609 0 : req = tevent_req_create(mem_ctx, &state,
4610 : struct dcerpc_clusapi_RemoveResourceDependency_state);
4611 0 : if (req == NULL) {
4612 0 : return NULL;
4613 : }
4614 0 : state->out_mem_ctx = NULL;
4615 :
4616 : /* In parameters */
4617 0 : state->orig.in.hResource = _hResource;
4618 0 : state->orig.in.hDependsOn = _hDependsOn;
4619 :
4620 : /* Out parameters */
4621 0 : state->orig.out.rpc_status = _rpc_status;
4622 :
4623 : /* Result */
4624 0 : NDR_ZERO_STRUCT(state->orig.out.result);
4625 :
4626 0 : state->out_mem_ctx = talloc_named_const(state, 0,
4627 : "dcerpc_clusapi_RemoveResourceDependency_out_memory");
4628 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4629 0 : return tevent_req_post(req, ev);
4630 : }
4631 :
4632 : /* make a temporary copy, that we pass to the dispatch function */
4633 0 : state->tmp = state->orig;
4634 :
4635 0 : subreq = dcerpc_clusapi_RemoveResourceDependency_r_send(state, ev, h, &state->tmp);
4636 0 : if (tevent_req_nomem(subreq, req)) {
4637 0 : return tevent_req_post(req, ev);
4638 : }
4639 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveResourceDependency_done, req);
4640 0 : return req;
4641 : }
4642 :
4643 0 : static void dcerpc_clusapi_RemoveResourceDependency_done(struct tevent_req *subreq)
4644 : {
4645 0 : struct tevent_req *req = tevent_req_callback_data(
4646 : subreq, struct tevent_req);
4647 0 : struct dcerpc_clusapi_RemoveResourceDependency_state *state = tevent_req_data(
4648 : req, struct dcerpc_clusapi_RemoveResourceDependency_state);
4649 : NTSTATUS status;
4650 : TALLOC_CTX *mem_ctx;
4651 :
4652 0 : if (state->out_mem_ctx) {
4653 0 : mem_ctx = state->out_mem_ctx;
4654 : } else {
4655 0 : mem_ctx = state;
4656 : }
4657 :
4658 0 : status = dcerpc_clusapi_RemoveResourceDependency_r_recv(subreq, mem_ctx);
4659 0 : TALLOC_FREE(subreq);
4660 0 : if (tevent_req_nterror(req, status)) {
4661 0 : return;
4662 : }
4663 :
4664 : /* Copy out parameters */
4665 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
4666 :
4667 : /* Copy result */
4668 0 : state->orig.out.result = state->tmp.out.result;
4669 :
4670 : /* Reset temporary structure */
4671 0 : NDR_ZERO_STRUCT(state->tmp);
4672 :
4673 0 : tevent_req_done(req);
4674 : }
4675 :
4676 0 : NTSTATUS dcerpc_clusapi_RemoveResourceDependency_recv(struct tevent_req *req,
4677 : TALLOC_CTX *mem_ctx,
4678 : WERROR *result)
4679 : {
4680 0 : struct dcerpc_clusapi_RemoveResourceDependency_state *state = tevent_req_data(
4681 : req, struct dcerpc_clusapi_RemoveResourceDependency_state);
4682 : NTSTATUS status;
4683 :
4684 0 : if (tevent_req_is_nterror(req, &status)) {
4685 0 : tevent_req_received(req);
4686 0 : return status;
4687 : }
4688 :
4689 : /* Steal possible out parameters to the callers context */
4690 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4691 :
4692 : /* Return result */
4693 0 : *result = state->orig.out.result;
4694 :
4695 0 : tevent_req_received(req);
4696 0 : return NT_STATUS_OK;
4697 : }
4698 :
4699 0 : NTSTATUS dcerpc_clusapi_RemoveResourceDependency(struct dcerpc_binding_handle *h,
4700 : TALLOC_CTX *mem_ctx,
4701 : struct policy_handle _hResource /* [in] */,
4702 : struct policy_handle _hDependsOn /* [in] */,
4703 : WERROR *_rpc_status /* [out] [ref] */,
4704 : WERROR *result)
4705 : {
4706 : struct clusapi_RemoveResourceDependency r;
4707 : NTSTATUS status;
4708 :
4709 : /* In parameters */
4710 0 : r.in.hResource = _hResource;
4711 0 : r.in.hDependsOn = _hDependsOn;
4712 :
4713 : /* Out parameters */
4714 0 : r.out.rpc_status = _rpc_status;
4715 :
4716 : /* Result */
4717 0 : NDR_ZERO_STRUCT(r.out.result);
4718 :
4719 0 : status = dcerpc_clusapi_RemoveResourceDependency_r(h, mem_ctx, &r);
4720 0 : if (!NT_STATUS_IS_OK(status)) {
4721 0 : return status;
4722 : }
4723 :
4724 : /* Return variables */
4725 0 : *_rpc_status = *r.out.rpc_status;
4726 :
4727 : /* Return result */
4728 0 : *result = r.out.result;
4729 :
4730 0 : return NT_STATUS_OK;
4731 : }
4732 :
4733 : struct dcerpc_clusapi_CanResourceBeDependent_r_state {
4734 : TALLOC_CTX *out_mem_ctx;
4735 : };
4736 :
4737 : static void dcerpc_clusapi_CanResourceBeDependent_r_done(struct tevent_req *subreq);
4738 :
4739 0 : struct tevent_req *dcerpc_clusapi_CanResourceBeDependent_r_send(TALLOC_CTX *mem_ctx,
4740 : struct tevent_context *ev,
4741 : struct dcerpc_binding_handle *h,
4742 : struct clusapi_CanResourceBeDependent *r)
4743 : {
4744 : struct tevent_req *req;
4745 : struct dcerpc_clusapi_CanResourceBeDependent_r_state *state;
4746 : struct tevent_req *subreq;
4747 :
4748 0 : req = tevent_req_create(mem_ctx, &state,
4749 : struct dcerpc_clusapi_CanResourceBeDependent_r_state);
4750 0 : if (req == NULL) {
4751 0 : return NULL;
4752 : }
4753 :
4754 0 : state->out_mem_ctx = talloc_new(state);
4755 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4756 0 : return tevent_req_post(req, ev);
4757 : }
4758 :
4759 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
4760 : NULL, &ndr_table_clusapi,
4761 0 : NDR_CLUSAPI_CANRESOURCEBEDEPENDENT, state->out_mem_ctx, r);
4762 0 : if (tevent_req_nomem(subreq, req)) {
4763 0 : return tevent_req_post(req, ev);
4764 : }
4765 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CanResourceBeDependent_r_done, req);
4766 :
4767 0 : return req;
4768 : }
4769 :
4770 0 : static void dcerpc_clusapi_CanResourceBeDependent_r_done(struct tevent_req *subreq)
4771 : {
4772 0 : struct tevent_req *req =
4773 0 : tevent_req_callback_data(subreq,
4774 : struct tevent_req);
4775 : NTSTATUS status;
4776 :
4777 0 : status = dcerpc_binding_handle_call_recv(subreq);
4778 0 : TALLOC_FREE(subreq);
4779 0 : if (tevent_req_nterror(req, status)) {
4780 0 : return;
4781 : }
4782 :
4783 0 : tevent_req_done(req);
4784 : }
4785 :
4786 0 : NTSTATUS dcerpc_clusapi_CanResourceBeDependent_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4787 : {
4788 0 : struct dcerpc_clusapi_CanResourceBeDependent_r_state *state =
4789 0 : tevent_req_data(req,
4790 : struct dcerpc_clusapi_CanResourceBeDependent_r_state);
4791 : NTSTATUS status;
4792 :
4793 0 : if (tevent_req_is_nterror(req, &status)) {
4794 0 : tevent_req_received(req);
4795 0 : return status;
4796 : }
4797 :
4798 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4799 :
4800 0 : tevent_req_received(req);
4801 0 : return NT_STATUS_OK;
4802 : }
4803 :
4804 0 : NTSTATUS dcerpc_clusapi_CanResourceBeDependent_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CanResourceBeDependent *r)
4805 : {
4806 : NTSTATUS status;
4807 :
4808 0 : status = dcerpc_binding_handle_call(h,
4809 : NULL, &ndr_table_clusapi,
4810 : NDR_CLUSAPI_CANRESOURCEBEDEPENDENT, mem_ctx, r);
4811 :
4812 0 : return status;
4813 : }
4814 :
4815 : struct dcerpc_clusapi_CanResourceBeDependent_state {
4816 : struct clusapi_CanResourceBeDependent orig;
4817 : struct clusapi_CanResourceBeDependent tmp;
4818 : TALLOC_CTX *out_mem_ctx;
4819 : };
4820 :
4821 : static void dcerpc_clusapi_CanResourceBeDependent_done(struct tevent_req *subreq);
4822 :
4823 0 : struct tevent_req *dcerpc_clusapi_CanResourceBeDependent_send(TALLOC_CTX *mem_ctx,
4824 : struct tevent_context *ev,
4825 : struct dcerpc_binding_handle *h,
4826 : struct policy_handle _hResource /* [in] */,
4827 : struct policy_handle _hResourceDependent /* [in] */,
4828 : WERROR *_rpc_status /* [out] [ref] */)
4829 : {
4830 : struct tevent_req *req;
4831 : struct dcerpc_clusapi_CanResourceBeDependent_state *state;
4832 : struct tevent_req *subreq;
4833 :
4834 0 : req = tevent_req_create(mem_ctx, &state,
4835 : struct dcerpc_clusapi_CanResourceBeDependent_state);
4836 0 : if (req == NULL) {
4837 0 : return NULL;
4838 : }
4839 0 : state->out_mem_ctx = NULL;
4840 :
4841 : /* In parameters */
4842 0 : state->orig.in.hResource = _hResource;
4843 0 : state->orig.in.hResourceDependent = _hResourceDependent;
4844 :
4845 : /* Out parameters */
4846 0 : state->orig.out.rpc_status = _rpc_status;
4847 :
4848 : /* Result */
4849 0 : NDR_ZERO_STRUCT(state->orig.out.result);
4850 :
4851 0 : state->out_mem_ctx = talloc_named_const(state, 0,
4852 : "dcerpc_clusapi_CanResourceBeDependent_out_memory");
4853 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4854 0 : return tevent_req_post(req, ev);
4855 : }
4856 :
4857 : /* make a temporary copy, that we pass to the dispatch function */
4858 0 : state->tmp = state->orig;
4859 :
4860 0 : subreq = dcerpc_clusapi_CanResourceBeDependent_r_send(state, ev, h, &state->tmp);
4861 0 : if (tevent_req_nomem(subreq, req)) {
4862 0 : return tevent_req_post(req, ev);
4863 : }
4864 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CanResourceBeDependent_done, req);
4865 0 : return req;
4866 : }
4867 :
4868 0 : static void dcerpc_clusapi_CanResourceBeDependent_done(struct tevent_req *subreq)
4869 : {
4870 0 : struct tevent_req *req = tevent_req_callback_data(
4871 : subreq, struct tevent_req);
4872 0 : struct dcerpc_clusapi_CanResourceBeDependent_state *state = tevent_req_data(
4873 : req, struct dcerpc_clusapi_CanResourceBeDependent_state);
4874 : NTSTATUS status;
4875 : TALLOC_CTX *mem_ctx;
4876 :
4877 0 : if (state->out_mem_ctx) {
4878 0 : mem_ctx = state->out_mem_ctx;
4879 : } else {
4880 0 : mem_ctx = state;
4881 : }
4882 :
4883 0 : status = dcerpc_clusapi_CanResourceBeDependent_r_recv(subreq, mem_ctx);
4884 0 : TALLOC_FREE(subreq);
4885 0 : if (tevent_req_nterror(req, status)) {
4886 0 : return;
4887 : }
4888 :
4889 : /* Copy out parameters */
4890 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
4891 :
4892 : /* Copy result */
4893 0 : state->orig.out.result = state->tmp.out.result;
4894 :
4895 : /* Reset temporary structure */
4896 0 : NDR_ZERO_STRUCT(state->tmp);
4897 :
4898 0 : tevent_req_done(req);
4899 : }
4900 :
4901 0 : NTSTATUS dcerpc_clusapi_CanResourceBeDependent_recv(struct tevent_req *req,
4902 : TALLOC_CTX *mem_ctx,
4903 : WERROR *result)
4904 : {
4905 0 : struct dcerpc_clusapi_CanResourceBeDependent_state *state = tevent_req_data(
4906 : req, struct dcerpc_clusapi_CanResourceBeDependent_state);
4907 : NTSTATUS status;
4908 :
4909 0 : if (tevent_req_is_nterror(req, &status)) {
4910 0 : tevent_req_received(req);
4911 0 : return status;
4912 : }
4913 :
4914 : /* Steal possible out parameters to the callers context */
4915 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
4916 :
4917 : /* Return result */
4918 0 : *result = state->orig.out.result;
4919 :
4920 0 : tevent_req_received(req);
4921 0 : return NT_STATUS_OK;
4922 : }
4923 :
4924 0 : NTSTATUS dcerpc_clusapi_CanResourceBeDependent(struct dcerpc_binding_handle *h,
4925 : TALLOC_CTX *mem_ctx,
4926 : struct policy_handle _hResource /* [in] */,
4927 : struct policy_handle _hResourceDependent /* [in] */,
4928 : WERROR *_rpc_status /* [out] [ref] */,
4929 : WERROR *result)
4930 : {
4931 : struct clusapi_CanResourceBeDependent r;
4932 : NTSTATUS status;
4933 :
4934 : /* In parameters */
4935 0 : r.in.hResource = _hResource;
4936 0 : r.in.hResourceDependent = _hResourceDependent;
4937 :
4938 : /* Out parameters */
4939 0 : r.out.rpc_status = _rpc_status;
4940 :
4941 : /* Result */
4942 0 : NDR_ZERO_STRUCT(r.out.result);
4943 :
4944 0 : status = dcerpc_clusapi_CanResourceBeDependent_r(h, mem_ctx, &r);
4945 0 : if (!NT_STATUS_IS_OK(status)) {
4946 0 : return status;
4947 : }
4948 :
4949 : /* Return variables */
4950 0 : *_rpc_status = *r.out.rpc_status;
4951 :
4952 : /* Return result */
4953 0 : *result = r.out.result;
4954 :
4955 0 : return NT_STATUS_OK;
4956 : }
4957 :
4958 : struct dcerpc_clusapi_CreateResEnum_r_state {
4959 : TALLOC_CTX *out_mem_ctx;
4960 : };
4961 :
4962 : static void dcerpc_clusapi_CreateResEnum_r_done(struct tevent_req *subreq);
4963 :
4964 0 : struct tevent_req *dcerpc_clusapi_CreateResEnum_r_send(TALLOC_CTX *mem_ctx,
4965 : struct tevent_context *ev,
4966 : struct dcerpc_binding_handle *h,
4967 : struct clusapi_CreateResEnum *r)
4968 : {
4969 : struct tevent_req *req;
4970 : struct dcerpc_clusapi_CreateResEnum_r_state *state;
4971 : struct tevent_req *subreq;
4972 :
4973 0 : req = tevent_req_create(mem_ctx, &state,
4974 : struct dcerpc_clusapi_CreateResEnum_r_state);
4975 0 : if (req == NULL) {
4976 0 : return NULL;
4977 : }
4978 :
4979 0 : state->out_mem_ctx = talloc_new(state);
4980 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
4981 0 : return tevent_req_post(req, ev);
4982 : }
4983 :
4984 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
4985 : NULL, &ndr_table_clusapi,
4986 0 : NDR_CLUSAPI_CREATERESENUM, state->out_mem_ctx, r);
4987 0 : if (tevent_req_nomem(subreq, req)) {
4988 0 : return tevent_req_post(req, ev);
4989 : }
4990 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResEnum_r_done, req);
4991 :
4992 0 : return req;
4993 : }
4994 :
4995 0 : static void dcerpc_clusapi_CreateResEnum_r_done(struct tevent_req *subreq)
4996 : {
4997 0 : struct tevent_req *req =
4998 0 : tevent_req_callback_data(subreq,
4999 : struct tevent_req);
5000 : NTSTATUS status;
5001 :
5002 0 : status = dcerpc_binding_handle_call_recv(subreq);
5003 0 : TALLOC_FREE(subreq);
5004 0 : if (tevent_req_nterror(req, status)) {
5005 0 : return;
5006 : }
5007 :
5008 0 : tevent_req_done(req);
5009 : }
5010 :
5011 0 : NTSTATUS dcerpc_clusapi_CreateResEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5012 : {
5013 0 : struct dcerpc_clusapi_CreateResEnum_r_state *state =
5014 0 : tevent_req_data(req,
5015 : struct dcerpc_clusapi_CreateResEnum_r_state);
5016 : NTSTATUS status;
5017 :
5018 0 : if (tevent_req_is_nterror(req, &status)) {
5019 0 : tevent_req_received(req);
5020 0 : return status;
5021 : }
5022 :
5023 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5024 :
5025 0 : tevent_req_received(req);
5026 0 : return NT_STATUS_OK;
5027 : }
5028 :
5029 0 : NTSTATUS dcerpc_clusapi_CreateResEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateResEnum *r)
5030 : {
5031 : NTSTATUS status;
5032 :
5033 0 : status = dcerpc_binding_handle_call(h,
5034 : NULL, &ndr_table_clusapi,
5035 : NDR_CLUSAPI_CREATERESENUM, mem_ctx, r);
5036 :
5037 0 : return status;
5038 : }
5039 :
5040 : struct dcerpc_clusapi_CreateResEnum_state {
5041 : struct clusapi_CreateResEnum orig;
5042 : struct clusapi_CreateResEnum tmp;
5043 : TALLOC_CTX *out_mem_ctx;
5044 : };
5045 :
5046 : static void dcerpc_clusapi_CreateResEnum_done(struct tevent_req *subreq);
5047 :
5048 0 : struct tevent_req *dcerpc_clusapi_CreateResEnum_send(TALLOC_CTX *mem_ctx,
5049 : struct tevent_context *ev,
5050 : struct dcerpc_binding_handle *h,
5051 : struct policy_handle _hResource /* [in] */,
5052 : uint32_t _dwType /* [in] */,
5053 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
5054 : WERROR *_rpc_status /* [out] [ref] */)
5055 : {
5056 : struct tevent_req *req;
5057 : struct dcerpc_clusapi_CreateResEnum_state *state;
5058 : struct tevent_req *subreq;
5059 :
5060 0 : req = tevent_req_create(mem_ctx, &state,
5061 : struct dcerpc_clusapi_CreateResEnum_state);
5062 0 : if (req == NULL) {
5063 0 : return NULL;
5064 : }
5065 0 : state->out_mem_ctx = NULL;
5066 :
5067 : /* In parameters */
5068 0 : state->orig.in.hResource = _hResource;
5069 0 : state->orig.in.dwType = _dwType;
5070 :
5071 : /* Out parameters */
5072 0 : state->orig.out.ReturnEnum = _ReturnEnum;
5073 0 : state->orig.out.rpc_status = _rpc_status;
5074 :
5075 : /* Result */
5076 0 : NDR_ZERO_STRUCT(state->orig.out.result);
5077 :
5078 0 : state->out_mem_ctx = talloc_named_const(state, 0,
5079 : "dcerpc_clusapi_CreateResEnum_out_memory");
5080 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5081 0 : return tevent_req_post(req, ev);
5082 : }
5083 :
5084 : /* make a temporary copy, that we pass to the dispatch function */
5085 0 : state->tmp = state->orig;
5086 :
5087 0 : subreq = dcerpc_clusapi_CreateResEnum_r_send(state, ev, h, &state->tmp);
5088 0 : if (tevent_req_nomem(subreq, req)) {
5089 0 : return tevent_req_post(req, ev);
5090 : }
5091 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResEnum_done, req);
5092 0 : return req;
5093 : }
5094 :
5095 0 : static void dcerpc_clusapi_CreateResEnum_done(struct tevent_req *subreq)
5096 : {
5097 0 : struct tevent_req *req = tevent_req_callback_data(
5098 : subreq, struct tevent_req);
5099 0 : struct dcerpc_clusapi_CreateResEnum_state *state = tevent_req_data(
5100 : req, struct dcerpc_clusapi_CreateResEnum_state);
5101 : NTSTATUS status;
5102 : TALLOC_CTX *mem_ctx;
5103 :
5104 0 : if (state->out_mem_ctx) {
5105 0 : mem_ctx = state->out_mem_ctx;
5106 : } else {
5107 0 : mem_ctx = state;
5108 : }
5109 :
5110 0 : status = dcerpc_clusapi_CreateResEnum_r_recv(subreq, mem_ctx);
5111 0 : TALLOC_FREE(subreq);
5112 0 : if (tevent_req_nterror(req, status)) {
5113 0 : return;
5114 : }
5115 :
5116 : /* Copy out parameters */
5117 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
5118 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
5119 :
5120 : /* Copy result */
5121 0 : state->orig.out.result = state->tmp.out.result;
5122 :
5123 : /* Reset temporary structure */
5124 0 : NDR_ZERO_STRUCT(state->tmp);
5125 :
5126 0 : tevent_req_done(req);
5127 : }
5128 :
5129 0 : NTSTATUS dcerpc_clusapi_CreateResEnum_recv(struct tevent_req *req,
5130 : TALLOC_CTX *mem_ctx,
5131 : WERROR *result)
5132 : {
5133 0 : struct dcerpc_clusapi_CreateResEnum_state *state = tevent_req_data(
5134 : req, struct dcerpc_clusapi_CreateResEnum_state);
5135 : NTSTATUS status;
5136 :
5137 0 : if (tevent_req_is_nterror(req, &status)) {
5138 0 : tevent_req_received(req);
5139 0 : return status;
5140 : }
5141 :
5142 : /* Steal possible out parameters to the callers context */
5143 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5144 :
5145 : /* Return result */
5146 0 : *result = state->orig.out.result;
5147 :
5148 0 : tevent_req_received(req);
5149 0 : return NT_STATUS_OK;
5150 : }
5151 :
5152 0 : NTSTATUS dcerpc_clusapi_CreateResEnum(struct dcerpc_binding_handle *h,
5153 : TALLOC_CTX *mem_ctx,
5154 : struct policy_handle _hResource /* [in] */,
5155 : uint32_t _dwType /* [in] */,
5156 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
5157 : WERROR *_rpc_status /* [out] [ref] */,
5158 : WERROR *result)
5159 : {
5160 : struct clusapi_CreateResEnum r;
5161 : NTSTATUS status;
5162 :
5163 : /* In parameters */
5164 0 : r.in.hResource = _hResource;
5165 0 : r.in.dwType = _dwType;
5166 :
5167 : /* Out parameters */
5168 0 : r.out.ReturnEnum = _ReturnEnum;
5169 0 : r.out.rpc_status = _rpc_status;
5170 :
5171 : /* Result */
5172 0 : NDR_ZERO_STRUCT(r.out.result);
5173 :
5174 0 : status = dcerpc_clusapi_CreateResEnum_r(h, mem_ctx, &r);
5175 0 : if (!NT_STATUS_IS_OK(status)) {
5176 0 : return status;
5177 : }
5178 :
5179 : /* Return variables */
5180 0 : *_ReturnEnum = *r.out.ReturnEnum;
5181 0 : *_rpc_status = *r.out.rpc_status;
5182 :
5183 : /* Return result */
5184 0 : *result = r.out.result;
5185 :
5186 0 : return NT_STATUS_OK;
5187 : }
5188 :
5189 : struct dcerpc_clusapi_AddResourceNode_r_state {
5190 : TALLOC_CTX *out_mem_ctx;
5191 : };
5192 :
5193 : static void dcerpc_clusapi_AddResourceNode_r_done(struct tevent_req *subreq);
5194 :
5195 0 : struct tevent_req *dcerpc_clusapi_AddResourceNode_r_send(TALLOC_CTX *mem_ctx,
5196 : struct tevent_context *ev,
5197 : struct dcerpc_binding_handle *h,
5198 : struct clusapi_AddResourceNode *r)
5199 : {
5200 : struct tevent_req *req;
5201 : struct dcerpc_clusapi_AddResourceNode_r_state *state;
5202 : struct tevent_req *subreq;
5203 :
5204 0 : req = tevent_req_create(mem_ctx, &state,
5205 : struct dcerpc_clusapi_AddResourceNode_r_state);
5206 0 : if (req == NULL) {
5207 0 : return NULL;
5208 : }
5209 :
5210 0 : state->out_mem_ctx = talloc_new(state);
5211 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5212 0 : return tevent_req_post(req, ev);
5213 : }
5214 :
5215 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
5216 : NULL, &ndr_table_clusapi,
5217 0 : NDR_CLUSAPI_ADDRESOURCENODE, state->out_mem_ctx, r);
5218 0 : if (tevent_req_nomem(subreq, req)) {
5219 0 : return tevent_req_post(req, ev);
5220 : }
5221 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddResourceNode_r_done, req);
5222 :
5223 0 : return req;
5224 : }
5225 :
5226 0 : static void dcerpc_clusapi_AddResourceNode_r_done(struct tevent_req *subreq)
5227 : {
5228 0 : struct tevent_req *req =
5229 0 : tevent_req_callback_data(subreq,
5230 : struct tevent_req);
5231 : NTSTATUS status;
5232 :
5233 0 : status = dcerpc_binding_handle_call_recv(subreq);
5234 0 : TALLOC_FREE(subreq);
5235 0 : if (tevent_req_nterror(req, status)) {
5236 0 : return;
5237 : }
5238 :
5239 0 : tevent_req_done(req);
5240 : }
5241 :
5242 0 : NTSTATUS dcerpc_clusapi_AddResourceNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5243 : {
5244 0 : struct dcerpc_clusapi_AddResourceNode_r_state *state =
5245 0 : tevent_req_data(req,
5246 : struct dcerpc_clusapi_AddResourceNode_r_state);
5247 : NTSTATUS status;
5248 :
5249 0 : if (tevent_req_is_nterror(req, &status)) {
5250 0 : tevent_req_received(req);
5251 0 : return status;
5252 : }
5253 :
5254 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5255 :
5256 0 : tevent_req_received(req);
5257 0 : return NT_STATUS_OK;
5258 : }
5259 :
5260 0 : NTSTATUS dcerpc_clusapi_AddResourceNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddResourceNode *r)
5261 : {
5262 : NTSTATUS status;
5263 :
5264 0 : status = dcerpc_binding_handle_call(h,
5265 : NULL, &ndr_table_clusapi,
5266 : NDR_CLUSAPI_ADDRESOURCENODE, mem_ctx, r);
5267 :
5268 0 : return status;
5269 : }
5270 :
5271 : struct dcerpc_clusapi_AddResourceNode_state {
5272 : struct clusapi_AddResourceNode orig;
5273 : struct clusapi_AddResourceNode tmp;
5274 : TALLOC_CTX *out_mem_ctx;
5275 : };
5276 :
5277 : static void dcerpc_clusapi_AddResourceNode_done(struct tevent_req *subreq);
5278 :
5279 0 : struct tevent_req *dcerpc_clusapi_AddResourceNode_send(TALLOC_CTX *mem_ctx,
5280 : struct tevent_context *ev,
5281 : struct dcerpc_binding_handle *h,
5282 : struct policy_handle _hResource /* [in] */,
5283 : struct policy_handle _hNode /* [in] */,
5284 : WERROR *_rpc_status /* [out] [ref] */)
5285 : {
5286 : struct tevent_req *req;
5287 : struct dcerpc_clusapi_AddResourceNode_state *state;
5288 : struct tevent_req *subreq;
5289 :
5290 0 : req = tevent_req_create(mem_ctx, &state,
5291 : struct dcerpc_clusapi_AddResourceNode_state);
5292 0 : if (req == NULL) {
5293 0 : return NULL;
5294 : }
5295 0 : state->out_mem_ctx = NULL;
5296 :
5297 : /* In parameters */
5298 0 : state->orig.in.hResource = _hResource;
5299 0 : state->orig.in.hNode = _hNode;
5300 :
5301 : /* Out parameters */
5302 0 : state->orig.out.rpc_status = _rpc_status;
5303 :
5304 : /* Result */
5305 0 : NDR_ZERO_STRUCT(state->orig.out.result);
5306 :
5307 0 : state->out_mem_ctx = talloc_named_const(state, 0,
5308 : "dcerpc_clusapi_AddResourceNode_out_memory");
5309 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5310 0 : return tevent_req_post(req, ev);
5311 : }
5312 :
5313 : /* make a temporary copy, that we pass to the dispatch function */
5314 0 : state->tmp = state->orig;
5315 :
5316 0 : subreq = dcerpc_clusapi_AddResourceNode_r_send(state, ev, h, &state->tmp);
5317 0 : if (tevent_req_nomem(subreq, req)) {
5318 0 : return tevent_req_post(req, ev);
5319 : }
5320 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddResourceNode_done, req);
5321 0 : return req;
5322 : }
5323 :
5324 0 : static void dcerpc_clusapi_AddResourceNode_done(struct tevent_req *subreq)
5325 : {
5326 0 : struct tevent_req *req = tevent_req_callback_data(
5327 : subreq, struct tevent_req);
5328 0 : struct dcerpc_clusapi_AddResourceNode_state *state = tevent_req_data(
5329 : req, struct dcerpc_clusapi_AddResourceNode_state);
5330 : NTSTATUS status;
5331 : TALLOC_CTX *mem_ctx;
5332 :
5333 0 : if (state->out_mem_ctx) {
5334 0 : mem_ctx = state->out_mem_ctx;
5335 : } else {
5336 0 : mem_ctx = state;
5337 : }
5338 :
5339 0 : status = dcerpc_clusapi_AddResourceNode_r_recv(subreq, mem_ctx);
5340 0 : TALLOC_FREE(subreq);
5341 0 : if (tevent_req_nterror(req, status)) {
5342 0 : return;
5343 : }
5344 :
5345 : /* Copy out parameters */
5346 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
5347 :
5348 : /* Copy result */
5349 0 : state->orig.out.result = state->tmp.out.result;
5350 :
5351 : /* Reset temporary structure */
5352 0 : NDR_ZERO_STRUCT(state->tmp);
5353 :
5354 0 : tevent_req_done(req);
5355 : }
5356 :
5357 0 : NTSTATUS dcerpc_clusapi_AddResourceNode_recv(struct tevent_req *req,
5358 : TALLOC_CTX *mem_ctx,
5359 : WERROR *result)
5360 : {
5361 0 : struct dcerpc_clusapi_AddResourceNode_state *state = tevent_req_data(
5362 : req, struct dcerpc_clusapi_AddResourceNode_state);
5363 : NTSTATUS status;
5364 :
5365 0 : if (tevent_req_is_nterror(req, &status)) {
5366 0 : tevent_req_received(req);
5367 0 : return status;
5368 : }
5369 :
5370 : /* Steal possible out parameters to the callers context */
5371 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5372 :
5373 : /* Return result */
5374 0 : *result = state->orig.out.result;
5375 :
5376 0 : tevent_req_received(req);
5377 0 : return NT_STATUS_OK;
5378 : }
5379 :
5380 0 : NTSTATUS dcerpc_clusapi_AddResourceNode(struct dcerpc_binding_handle *h,
5381 : TALLOC_CTX *mem_ctx,
5382 : struct policy_handle _hResource /* [in] */,
5383 : struct policy_handle _hNode /* [in] */,
5384 : WERROR *_rpc_status /* [out] [ref] */,
5385 : WERROR *result)
5386 : {
5387 : struct clusapi_AddResourceNode r;
5388 : NTSTATUS status;
5389 :
5390 : /* In parameters */
5391 0 : r.in.hResource = _hResource;
5392 0 : r.in.hNode = _hNode;
5393 :
5394 : /* Out parameters */
5395 0 : r.out.rpc_status = _rpc_status;
5396 :
5397 : /* Result */
5398 0 : NDR_ZERO_STRUCT(r.out.result);
5399 :
5400 0 : status = dcerpc_clusapi_AddResourceNode_r(h, mem_ctx, &r);
5401 0 : if (!NT_STATUS_IS_OK(status)) {
5402 0 : return status;
5403 : }
5404 :
5405 : /* Return variables */
5406 0 : *_rpc_status = *r.out.rpc_status;
5407 :
5408 : /* Return result */
5409 0 : *result = r.out.result;
5410 :
5411 0 : return NT_STATUS_OK;
5412 : }
5413 :
5414 : struct dcerpc_clusapi_RemoveResourceNode_r_state {
5415 : TALLOC_CTX *out_mem_ctx;
5416 : };
5417 :
5418 : static void dcerpc_clusapi_RemoveResourceNode_r_done(struct tevent_req *subreq);
5419 :
5420 0 : struct tevent_req *dcerpc_clusapi_RemoveResourceNode_r_send(TALLOC_CTX *mem_ctx,
5421 : struct tevent_context *ev,
5422 : struct dcerpc_binding_handle *h,
5423 : struct clusapi_RemoveResourceNode *r)
5424 : {
5425 : struct tevent_req *req;
5426 : struct dcerpc_clusapi_RemoveResourceNode_r_state *state;
5427 : struct tevent_req *subreq;
5428 :
5429 0 : req = tevent_req_create(mem_ctx, &state,
5430 : struct dcerpc_clusapi_RemoveResourceNode_r_state);
5431 0 : if (req == NULL) {
5432 0 : return NULL;
5433 : }
5434 :
5435 0 : state->out_mem_ctx = talloc_new(state);
5436 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5437 0 : return tevent_req_post(req, ev);
5438 : }
5439 :
5440 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
5441 : NULL, &ndr_table_clusapi,
5442 0 : NDR_CLUSAPI_REMOVERESOURCENODE, state->out_mem_ctx, r);
5443 0 : if (tevent_req_nomem(subreq, req)) {
5444 0 : return tevent_req_post(req, ev);
5445 : }
5446 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveResourceNode_r_done, req);
5447 :
5448 0 : return req;
5449 : }
5450 :
5451 0 : static void dcerpc_clusapi_RemoveResourceNode_r_done(struct tevent_req *subreq)
5452 : {
5453 0 : struct tevent_req *req =
5454 0 : tevent_req_callback_data(subreq,
5455 : struct tevent_req);
5456 : NTSTATUS status;
5457 :
5458 0 : status = dcerpc_binding_handle_call_recv(subreq);
5459 0 : TALLOC_FREE(subreq);
5460 0 : if (tevent_req_nterror(req, status)) {
5461 0 : return;
5462 : }
5463 :
5464 0 : tevent_req_done(req);
5465 : }
5466 :
5467 0 : NTSTATUS dcerpc_clusapi_RemoveResourceNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5468 : {
5469 0 : struct dcerpc_clusapi_RemoveResourceNode_r_state *state =
5470 0 : tevent_req_data(req,
5471 : struct dcerpc_clusapi_RemoveResourceNode_r_state);
5472 : NTSTATUS status;
5473 :
5474 0 : if (tevent_req_is_nterror(req, &status)) {
5475 0 : tevent_req_received(req);
5476 0 : return status;
5477 : }
5478 :
5479 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5480 :
5481 0 : tevent_req_received(req);
5482 0 : return NT_STATUS_OK;
5483 : }
5484 :
5485 0 : NTSTATUS dcerpc_clusapi_RemoveResourceNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveResourceNode *r)
5486 : {
5487 : NTSTATUS status;
5488 :
5489 0 : status = dcerpc_binding_handle_call(h,
5490 : NULL, &ndr_table_clusapi,
5491 : NDR_CLUSAPI_REMOVERESOURCENODE, mem_ctx, r);
5492 :
5493 0 : return status;
5494 : }
5495 :
5496 : struct dcerpc_clusapi_RemoveResourceNode_state {
5497 : struct clusapi_RemoveResourceNode orig;
5498 : struct clusapi_RemoveResourceNode tmp;
5499 : TALLOC_CTX *out_mem_ctx;
5500 : };
5501 :
5502 : static void dcerpc_clusapi_RemoveResourceNode_done(struct tevent_req *subreq);
5503 :
5504 0 : struct tevent_req *dcerpc_clusapi_RemoveResourceNode_send(TALLOC_CTX *mem_ctx,
5505 : struct tevent_context *ev,
5506 : struct dcerpc_binding_handle *h,
5507 : struct policy_handle _hResource /* [in] */,
5508 : struct policy_handle _hNode /* [in] */,
5509 : WERROR *_rpc_status /* [out] [ref] */)
5510 : {
5511 : struct tevent_req *req;
5512 : struct dcerpc_clusapi_RemoveResourceNode_state *state;
5513 : struct tevent_req *subreq;
5514 :
5515 0 : req = tevent_req_create(mem_ctx, &state,
5516 : struct dcerpc_clusapi_RemoveResourceNode_state);
5517 0 : if (req == NULL) {
5518 0 : return NULL;
5519 : }
5520 0 : state->out_mem_ctx = NULL;
5521 :
5522 : /* In parameters */
5523 0 : state->orig.in.hResource = _hResource;
5524 0 : state->orig.in.hNode = _hNode;
5525 :
5526 : /* Out parameters */
5527 0 : state->orig.out.rpc_status = _rpc_status;
5528 :
5529 : /* Result */
5530 0 : NDR_ZERO_STRUCT(state->orig.out.result);
5531 :
5532 0 : state->out_mem_ctx = talloc_named_const(state, 0,
5533 : "dcerpc_clusapi_RemoveResourceNode_out_memory");
5534 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5535 0 : return tevent_req_post(req, ev);
5536 : }
5537 :
5538 : /* make a temporary copy, that we pass to the dispatch function */
5539 0 : state->tmp = state->orig;
5540 :
5541 0 : subreq = dcerpc_clusapi_RemoveResourceNode_r_send(state, ev, h, &state->tmp);
5542 0 : if (tevent_req_nomem(subreq, req)) {
5543 0 : return tevent_req_post(req, ev);
5544 : }
5545 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveResourceNode_done, req);
5546 0 : return req;
5547 : }
5548 :
5549 0 : static void dcerpc_clusapi_RemoveResourceNode_done(struct tevent_req *subreq)
5550 : {
5551 0 : struct tevent_req *req = tevent_req_callback_data(
5552 : subreq, struct tevent_req);
5553 0 : struct dcerpc_clusapi_RemoveResourceNode_state *state = tevent_req_data(
5554 : req, struct dcerpc_clusapi_RemoveResourceNode_state);
5555 : NTSTATUS status;
5556 : TALLOC_CTX *mem_ctx;
5557 :
5558 0 : if (state->out_mem_ctx) {
5559 0 : mem_ctx = state->out_mem_ctx;
5560 : } else {
5561 0 : mem_ctx = state;
5562 : }
5563 :
5564 0 : status = dcerpc_clusapi_RemoveResourceNode_r_recv(subreq, mem_ctx);
5565 0 : TALLOC_FREE(subreq);
5566 0 : if (tevent_req_nterror(req, status)) {
5567 0 : return;
5568 : }
5569 :
5570 : /* Copy out parameters */
5571 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
5572 :
5573 : /* Copy result */
5574 0 : state->orig.out.result = state->tmp.out.result;
5575 :
5576 : /* Reset temporary structure */
5577 0 : NDR_ZERO_STRUCT(state->tmp);
5578 :
5579 0 : tevent_req_done(req);
5580 : }
5581 :
5582 0 : NTSTATUS dcerpc_clusapi_RemoveResourceNode_recv(struct tevent_req *req,
5583 : TALLOC_CTX *mem_ctx,
5584 : WERROR *result)
5585 : {
5586 0 : struct dcerpc_clusapi_RemoveResourceNode_state *state = tevent_req_data(
5587 : req, struct dcerpc_clusapi_RemoveResourceNode_state);
5588 : NTSTATUS status;
5589 :
5590 0 : if (tevent_req_is_nterror(req, &status)) {
5591 0 : tevent_req_received(req);
5592 0 : return status;
5593 : }
5594 :
5595 : /* Steal possible out parameters to the callers context */
5596 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5597 :
5598 : /* Return result */
5599 0 : *result = state->orig.out.result;
5600 :
5601 0 : tevent_req_received(req);
5602 0 : return NT_STATUS_OK;
5603 : }
5604 :
5605 0 : NTSTATUS dcerpc_clusapi_RemoveResourceNode(struct dcerpc_binding_handle *h,
5606 : TALLOC_CTX *mem_ctx,
5607 : struct policy_handle _hResource /* [in] */,
5608 : struct policy_handle _hNode /* [in] */,
5609 : WERROR *_rpc_status /* [out] [ref] */,
5610 : WERROR *result)
5611 : {
5612 : struct clusapi_RemoveResourceNode r;
5613 : NTSTATUS status;
5614 :
5615 : /* In parameters */
5616 0 : r.in.hResource = _hResource;
5617 0 : r.in.hNode = _hNode;
5618 :
5619 : /* Out parameters */
5620 0 : r.out.rpc_status = _rpc_status;
5621 :
5622 : /* Result */
5623 0 : NDR_ZERO_STRUCT(r.out.result);
5624 :
5625 0 : status = dcerpc_clusapi_RemoveResourceNode_r(h, mem_ctx, &r);
5626 0 : if (!NT_STATUS_IS_OK(status)) {
5627 0 : return status;
5628 : }
5629 :
5630 : /* Return variables */
5631 0 : *_rpc_status = *r.out.rpc_status;
5632 :
5633 : /* Return result */
5634 0 : *result = r.out.result;
5635 :
5636 0 : return NT_STATUS_OK;
5637 : }
5638 :
5639 : struct dcerpc_clusapi_ChangeResourceGroup_r_state {
5640 : TALLOC_CTX *out_mem_ctx;
5641 : };
5642 :
5643 : static void dcerpc_clusapi_ChangeResourceGroup_r_done(struct tevent_req *subreq);
5644 :
5645 0 : struct tevent_req *dcerpc_clusapi_ChangeResourceGroup_r_send(TALLOC_CTX *mem_ctx,
5646 : struct tevent_context *ev,
5647 : struct dcerpc_binding_handle *h,
5648 : struct clusapi_ChangeResourceGroup *r)
5649 : {
5650 : struct tevent_req *req;
5651 : struct dcerpc_clusapi_ChangeResourceGroup_r_state *state;
5652 : struct tevent_req *subreq;
5653 :
5654 0 : req = tevent_req_create(mem_ctx, &state,
5655 : struct dcerpc_clusapi_ChangeResourceGroup_r_state);
5656 0 : if (req == NULL) {
5657 0 : return NULL;
5658 : }
5659 :
5660 0 : state->out_mem_ctx = talloc_new(state);
5661 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5662 0 : return tevent_req_post(req, ev);
5663 : }
5664 :
5665 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
5666 : NULL, &ndr_table_clusapi,
5667 0 : NDR_CLUSAPI_CHANGERESOURCEGROUP, state->out_mem_ctx, r);
5668 0 : if (tevent_req_nomem(subreq, req)) {
5669 0 : return tevent_req_post(req, ev);
5670 : }
5671 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeResourceGroup_r_done, req);
5672 :
5673 0 : return req;
5674 : }
5675 :
5676 0 : static void dcerpc_clusapi_ChangeResourceGroup_r_done(struct tevent_req *subreq)
5677 : {
5678 0 : struct tevent_req *req =
5679 0 : tevent_req_callback_data(subreq,
5680 : struct tevent_req);
5681 : NTSTATUS status;
5682 :
5683 0 : status = dcerpc_binding_handle_call_recv(subreq);
5684 0 : TALLOC_FREE(subreq);
5685 0 : if (tevent_req_nterror(req, status)) {
5686 0 : return;
5687 : }
5688 :
5689 0 : tevent_req_done(req);
5690 : }
5691 :
5692 0 : NTSTATUS dcerpc_clusapi_ChangeResourceGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5693 : {
5694 0 : struct dcerpc_clusapi_ChangeResourceGroup_r_state *state =
5695 0 : tevent_req_data(req,
5696 : struct dcerpc_clusapi_ChangeResourceGroup_r_state);
5697 : NTSTATUS status;
5698 :
5699 0 : if (tevent_req_is_nterror(req, &status)) {
5700 0 : tevent_req_received(req);
5701 0 : return status;
5702 : }
5703 :
5704 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5705 :
5706 0 : tevent_req_received(req);
5707 0 : return NT_STATUS_OK;
5708 : }
5709 :
5710 0 : NTSTATUS dcerpc_clusapi_ChangeResourceGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ChangeResourceGroup *r)
5711 : {
5712 : NTSTATUS status;
5713 :
5714 0 : status = dcerpc_binding_handle_call(h,
5715 : NULL, &ndr_table_clusapi,
5716 : NDR_CLUSAPI_CHANGERESOURCEGROUP, mem_ctx, r);
5717 :
5718 0 : return status;
5719 : }
5720 :
5721 : struct dcerpc_clusapi_ChangeResourceGroup_state {
5722 : struct clusapi_ChangeResourceGroup orig;
5723 : struct clusapi_ChangeResourceGroup tmp;
5724 : TALLOC_CTX *out_mem_ctx;
5725 : };
5726 :
5727 : static void dcerpc_clusapi_ChangeResourceGroup_done(struct tevent_req *subreq);
5728 :
5729 0 : struct tevent_req *dcerpc_clusapi_ChangeResourceGroup_send(TALLOC_CTX *mem_ctx,
5730 : struct tevent_context *ev,
5731 : struct dcerpc_binding_handle *h,
5732 : struct policy_handle _hResource /* [in] */,
5733 : struct policy_handle _hGroup /* [in] */,
5734 : WERROR *_rpc_status /* [out] [ref] */)
5735 : {
5736 : struct tevent_req *req;
5737 : struct dcerpc_clusapi_ChangeResourceGroup_state *state;
5738 : struct tevent_req *subreq;
5739 :
5740 0 : req = tevent_req_create(mem_ctx, &state,
5741 : struct dcerpc_clusapi_ChangeResourceGroup_state);
5742 0 : if (req == NULL) {
5743 0 : return NULL;
5744 : }
5745 0 : state->out_mem_ctx = NULL;
5746 :
5747 : /* In parameters */
5748 0 : state->orig.in.hResource = _hResource;
5749 0 : state->orig.in.hGroup = _hGroup;
5750 :
5751 : /* Out parameters */
5752 0 : state->orig.out.rpc_status = _rpc_status;
5753 :
5754 : /* Result */
5755 0 : NDR_ZERO_STRUCT(state->orig.out.result);
5756 :
5757 0 : state->out_mem_ctx = talloc_named_const(state, 0,
5758 : "dcerpc_clusapi_ChangeResourceGroup_out_memory");
5759 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5760 0 : return tevent_req_post(req, ev);
5761 : }
5762 :
5763 : /* make a temporary copy, that we pass to the dispatch function */
5764 0 : state->tmp = state->orig;
5765 :
5766 0 : subreq = dcerpc_clusapi_ChangeResourceGroup_r_send(state, ev, h, &state->tmp);
5767 0 : if (tevent_req_nomem(subreq, req)) {
5768 0 : return tevent_req_post(req, ev);
5769 : }
5770 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeResourceGroup_done, req);
5771 0 : return req;
5772 : }
5773 :
5774 0 : static void dcerpc_clusapi_ChangeResourceGroup_done(struct tevent_req *subreq)
5775 : {
5776 0 : struct tevent_req *req = tevent_req_callback_data(
5777 : subreq, struct tevent_req);
5778 0 : struct dcerpc_clusapi_ChangeResourceGroup_state *state = tevent_req_data(
5779 : req, struct dcerpc_clusapi_ChangeResourceGroup_state);
5780 : NTSTATUS status;
5781 : TALLOC_CTX *mem_ctx;
5782 :
5783 0 : if (state->out_mem_ctx) {
5784 0 : mem_ctx = state->out_mem_ctx;
5785 : } else {
5786 0 : mem_ctx = state;
5787 : }
5788 :
5789 0 : status = dcerpc_clusapi_ChangeResourceGroup_r_recv(subreq, mem_ctx);
5790 0 : TALLOC_FREE(subreq);
5791 0 : if (tevent_req_nterror(req, status)) {
5792 0 : return;
5793 : }
5794 :
5795 : /* Copy out parameters */
5796 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
5797 :
5798 : /* Copy result */
5799 0 : state->orig.out.result = state->tmp.out.result;
5800 :
5801 : /* Reset temporary structure */
5802 0 : NDR_ZERO_STRUCT(state->tmp);
5803 :
5804 0 : tevent_req_done(req);
5805 : }
5806 :
5807 0 : NTSTATUS dcerpc_clusapi_ChangeResourceGroup_recv(struct tevent_req *req,
5808 : TALLOC_CTX *mem_ctx,
5809 : WERROR *result)
5810 : {
5811 0 : struct dcerpc_clusapi_ChangeResourceGroup_state *state = tevent_req_data(
5812 : req, struct dcerpc_clusapi_ChangeResourceGroup_state);
5813 : NTSTATUS status;
5814 :
5815 0 : if (tevent_req_is_nterror(req, &status)) {
5816 0 : tevent_req_received(req);
5817 0 : return status;
5818 : }
5819 :
5820 : /* Steal possible out parameters to the callers context */
5821 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5822 :
5823 : /* Return result */
5824 0 : *result = state->orig.out.result;
5825 :
5826 0 : tevent_req_received(req);
5827 0 : return NT_STATUS_OK;
5828 : }
5829 :
5830 0 : NTSTATUS dcerpc_clusapi_ChangeResourceGroup(struct dcerpc_binding_handle *h,
5831 : TALLOC_CTX *mem_ctx,
5832 : struct policy_handle _hResource /* [in] */,
5833 : struct policy_handle _hGroup /* [in] */,
5834 : WERROR *_rpc_status /* [out] [ref] */,
5835 : WERROR *result)
5836 : {
5837 : struct clusapi_ChangeResourceGroup r;
5838 : NTSTATUS status;
5839 :
5840 : /* In parameters */
5841 0 : r.in.hResource = _hResource;
5842 0 : r.in.hGroup = _hGroup;
5843 :
5844 : /* Out parameters */
5845 0 : r.out.rpc_status = _rpc_status;
5846 :
5847 : /* Result */
5848 0 : NDR_ZERO_STRUCT(r.out.result);
5849 :
5850 0 : status = dcerpc_clusapi_ChangeResourceGroup_r(h, mem_ctx, &r);
5851 0 : if (!NT_STATUS_IS_OK(status)) {
5852 0 : return status;
5853 : }
5854 :
5855 : /* Return variables */
5856 0 : *_rpc_status = *r.out.rpc_status;
5857 :
5858 : /* Return result */
5859 0 : *result = r.out.result;
5860 :
5861 0 : return NT_STATUS_OK;
5862 : }
5863 :
5864 : struct dcerpc_clusapi_CreateResourceType_r_state {
5865 : TALLOC_CTX *out_mem_ctx;
5866 : };
5867 :
5868 : static void dcerpc_clusapi_CreateResourceType_r_done(struct tevent_req *subreq);
5869 :
5870 0 : struct tevent_req *dcerpc_clusapi_CreateResourceType_r_send(TALLOC_CTX *mem_ctx,
5871 : struct tevent_context *ev,
5872 : struct dcerpc_binding_handle *h,
5873 : struct clusapi_CreateResourceType *r)
5874 : {
5875 : struct tevent_req *req;
5876 : struct dcerpc_clusapi_CreateResourceType_r_state *state;
5877 : struct tevent_req *subreq;
5878 :
5879 0 : req = tevent_req_create(mem_ctx, &state,
5880 : struct dcerpc_clusapi_CreateResourceType_r_state);
5881 0 : if (req == NULL) {
5882 0 : return NULL;
5883 : }
5884 :
5885 0 : state->out_mem_ctx = talloc_new(state);
5886 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5887 0 : return tevent_req_post(req, ev);
5888 : }
5889 :
5890 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
5891 : NULL, &ndr_table_clusapi,
5892 0 : NDR_CLUSAPI_CREATERESOURCETYPE, state->out_mem_ctx, r);
5893 0 : if (tevent_req_nomem(subreq, req)) {
5894 0 : return tevent_req_post(req, ev);
5895 : }
5896 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResourceType_r_done, req);
5897 :
5898 0 : return req;
5899 : }
5900 :
5901 0 : static void dcerpc_clusapi_CreateResourceType_r_done(struct tevent_req *subreq)
5902 : {
5903 0 : struct tevent_req *req =
5904 0 : tevent_req_callback_data(subreq,
5905 : struct tevent_req);
5906 : NTSTATUS status;
5907 :
5908 0 : status = dcerpc_binding_handle_call_recv(subreq);
5909 0 : TALLOC_FREE(subreq);
5910 0 : if (tevent_req_nterror(req, status)) {
5911 0 : return;
5912 : }
5913 :
5914 0 : tevent_req_done(req);
5915 : }
5916 :
5917 0 : NTSTATUS dcerpc_clusapi_CreateResourceType_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5918 : {
5919 0 : struct dcerpc_clusapi_CreateResourceType_r_state *state =
5920 0 : tevent_req_data(req,
5921 : struct dcerpc_clusapi_CreateResourceType_r_state);
5922 : NTSTATUS status;
5923 :
5924 0 : if (tevent_req_is_nterror(req, &status)) {
5925 0 : tevent_req_received(req);
5926 0 : return status;
5927 : }
5928 :
5929 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
5930 :
5931 0 : tevent_req_received(req);
5932 0 : return NT_STATUS_OK;
5933 : }
5934 :
5935 0 : NTSTATUS dcerpc_clusapi_CreateResourceType_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateResourceType *r)
5936 : {
5937 : NTSTATUS status;
5938 :
5939 0 : status = dcerpc_binding_handle_call(h,
5940 : NULL, &ndr_table_clusapi,
5941 : NDR_CLUSAPI_CREATERESOURCETYPE, mem_ctx, r);
5942 :
5943 0 : return status;
5944 : }
5945 :
5946 : struct dcerpc_clusapi_CreateResourceType_state {
5947 : struct clusapi_CreateResourceType orig;
5948 : struct clusapi_CreateResourceType tmp;
5949 : TALLOC_CTX *out_mem_ctx;
5950 : };
5951 :
5952 : static void dcerpc_clusapi_CreateResourceType_done(struct tevent_req *subreq);
5953 :
5954 0 : struct tevent_req *dcerpc_clusapi_CreateResourceType_send(TALLOC_CTX *mem_ctx,
5955 : struct tevent_context *ev,
5956 : struct dcerpc_binding_handle *h,
5957 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
5958 : const char *_lpszDisplayName /* [in] [charset(UTF16),ref] */,
5959 : const char *_lpszDllName /* [in] [charset(UTF16),ref] */,
5960 : uint32_t _dwLooksAlive /* [in] */,
5961 : uint32_t _dwIsAlive /* [in] */,
5962 : WERROR *_rpc_status /* [out] [ref] */)
5963 : {
5964 : struct tevent_req *req;
5965 : struct dcerpc_clusapi_CreateResourceType_state *state;
5966 : struct tevent_req *subreq;
5967 :
5968 0 : req = tevent_req_create(mem_ctx, &state,
5969 : struct dcerpc_clusapi_CreateResourceType_state);
5970 0 : if (req == NULL) {
5971 0 : return NULL;
5972 : }
5973 0 : state->out_mem_ctx = NULL;
5974 :
5975 : /* In parameters */
5976 0 : state->orig.in.lpszTypeName = _lpszTypeName;
5977 0 : state->orig.in.lpszDisplayName = _lpszDisplayName;
5978 0 : state->orig.in.lpszDllName = _lpszDllName;
5979 0 : state->orig.in.dwLooksAlive = _dwLooksAlive;
5980 0 : state->orig.in.dwIsAlive = _dwIsAlive;
5981 :
5982 : /* Out parameters */
5983 0 : state->orig.out.rpc_status = _rpc_status;
5984 :
5985 : /* Result */
5986 0 : NDR_ZERO_STRUCT(state->orig.out.result);
5987 :
5988 0 : state->out_mem_ctx = talloc_named_const(state, 0,
5989 : "dcerpc_clusapi_CreateResourceType_out_memory");
5990 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
5991 0 : return tevent_req_post(req, ev);
5992 : }
5993 :
5994 : /* make a temporary copy, that we pass to the dispatch function */
5995 0 : state->tmp = state->orig;
5996 :
5997 0 : subreq = dcerpc_clusapi_CreateResourceType_r_send(state, ev, h, &state->tmp);
5998 0 : if (tevent_req_nomem(subreq, req)) {
5999 0 : return tevent_req_post(req, ev);
6000 : }
6001 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResourceType_done, req);
6002 0 : return req;
6003 : }
6004 :
6005 0 : static void dcerpc_clusapi_CreateResourceType_done(struct tevent_req *subreq)
6006 : {
6007 0 : struct tevent_req *req = tevent_req_callback_data(
6008 : subreq, struct tevent_req);
6009 0 : struct dcerpc_clusapi_CreateResourceType_state *state = tevent_req_data(
6010 : req, struct dcerpc_clusapi_CreateResourceType_state);
6011 : NTSTATUS status;
6012 : TALLOC_CTX *mem_ctx;
6013 :
6014 0 : if (state->out_mem_ctx) {
6015 0 : mem_ctx = state->out_mem_ctx;
6016 : } else {
6017 0 : mem_ctx = state;
6018 : }
6019 :
6020 0 : status = dcerpc_clusapi_CreateResourceType_r_recv(subreq, mem_ctx);
6021 0 : TALLOC_FREE(subreq);
6022 0 : if (tevent_req_nterror(req, status)) {
6023 0 : return;
6024 : }
6025 :
6026 : /* Copy out parameters */
6027 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
6028 :
6029 : /* Copy result */
6030 0 : state->orig.out.result = state->tmp.out.result;
6031 :
6032 : /* Reset temporary structure */
6033 0 : NDR_ZERO_STRUCT(state->tmp);
6034 :
6035 0 : tevent_req_done(req);
6036 : }
6037 :
6038 0 : NTSTATUS dcerpc_clusapi_CreateResourceType_recv(struct tevent_req *req,
6039 : TALLOC_CTX *mem_ctx,
6040 : WERROR *result)
6041 : {
6042 0 : struct dcerpc_clusapi_CreateResourceType_state *state = tevent_req_data(
6043 : req, struct dcerpc_clusapi_CreateResourceType_state);
6044 : NTSTATUS status;
6045 :
6046 0 : if (tevent_req_is_nterror(req, &status)) {
6047 0 : tevent_req_received(req);
6048 0 : return status;
6049 : }
6050 :
6051 : /* Steal possible out parameters to the callers context */
6052 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6053 :
6054 : /* Return result */
6055 0 : *result = state->orig.out.result;
6056 :
6057 0 : tevent_req_received(req);
6058 0 : return NT_STATUS_OK;
6059 : }
6060 :
6061 0 : NTSTATUS dcerpc_clusapi_CreateResourceType(struct dcerpc_binding_handle *h,
6062 : TALLOC_CTX *mem_ctx,
6063 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
6064 : const char *_lpszDisplayName /* [in] [charset(UTF16),ref] */,
6065 : const char *_lpszDllName /* [in] [charset(UTF16),ref] */,
6066 : uint32_t _dwLooksAlive /* [in] */,
6067 : uint32_t _dwIsAlive /* [in] */,
6068 : WERROR *_rpc_status /* [out] [ref] */,
6069 : WERROR *result)
6070 : {
6071 : struct clusapi_CreateResourceType r;
6072 : NTSTATUS status;
6073 :
6074 : /* In parameters */
6075 0 : r.in.lpszTypeName = _lpszTypeName;
6076 0 : r.in.lpszDisplayName = _lpszDisplayName;
6077 0 : r.in.lpszDllName = _lpszDllName;
6078 0 : r.in.dwLooksAlive = _dwLooksAlive;
6079 0 : r.in.dwIsAlive = _dwIsAlive;
6080 :
6081 : /* Out parameters */
6082 0 : r.out.rpc_status = _rpc_status;
6083 :
6084 : /* Result */
6085 0 : NDR_ZERO_STRUCT(r.out.result);
6086 :
6087 0 : status = dcerpc_clusapi_CreateResourceType_r(h, mem_ctx, &r);
6088 0 : if (!NT_STATUS_IS_OK(status)) {
6089 0 : return status;
6090 : }
6091 :
6092 : /* Return variables */
6093 0 : *_rpc_status = *r.out.rpc_status;
6094 :
6095 : /* Return result */
6096 0 : *result = r.out.result;
6097 :
6098 0 : return NT_STATUS_OK;
6099 : }
6100 :
6101 : struct dcerpc_clusapi_DeleteResourceType_r_state {
6102 : TALLOC_CTX *out_mem_ctx;
6103 : };
6104 :
6105 : static void dcerpc_clusapi_DeleteResourceType_r_done(struct tevent_req *subreq);
6106 :
6107 0 : struct tevent_req *dcerpc_clusapi_DeleteResourceType_r_send(TALLOC_CTX *mem_ctx,
6108 : struct tevent_context *ev,
6109 : struct dcerpc_binding_handle *h,
6110 : struct clusapi_DeleteResourceType *r)
6111 : {
6112 : struct tevent_req *req;
6113 : struct dcerpc_clusapi_DeleteResourceType_r_state *state;
6114 : struct tevent_req *subreq;
6115 :
6116 0 : req = tevent_req_create(mem_ctx, &state,
6117 : struct dcerpc_clusapi_DeleteResourceType_r_state);
6118 0 : if (req == NULL) {
6119 0 : return NULL;
6120 : }
6121 :
6122 0 : state->out_mem_ctx = talloc_new(state);
6123 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6124 0 : return tevent_req_post(req, ev);
6125 : }
6126 :
6127 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
6128 : NULL, &ndr_table_clusapi,
6129 0 : NDR_CLUSAPI_DELETERESOURCETYPE, state->out_mem_ctx, r);
6130 0 : if (tevent_req_nomem(subreq, req)) {
6131 0 : return tevent_req_post(req, ev);
6132 : }
6133 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteResourceType_r_done, req);
6134 :
6135 0 : return req;
6136 : }
6137 :
6138 0 : static void dcerpc_clusapi_DeleteResourceType_r_done(struct tevent_req *subreq)
6139 : {
6140 0 : struct tevent_req *req =
6141 0 : tevent_req_callback_data(subreq,
6142 : struct tevent_req);
6143 : NTSTATUS status;
6144 :
6145 0 : status = dcerpc_binding_handle_call_recv(subreq);
6146 0 : TALLOC_FREE(subreq);
6147 0 : if (tevent_req_nterror(req, status)) {
6148 0 : return;
6149 : }
6150 :
6151 0 : tevent_req_done(req);
6152 : }
6153 :
6154 0 : NTSTATUS dcerpc_clusapi_DeleteResourceType_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6155 : {
6156 0 : struct dcerpc_clusapi_DeleteResourceType_r_state *state =
6157 0 : tevent_req_data(req,
6158 : struct dcerpc_clusapi_DeleteResourceType_r_state);
6159 : NTSTATUS status;
6160 :
6161 0 : if (tevent_req_is_nterror(req, &status)) {
6162 0 : tevent_req_received(req);
6163 0 : return status;
6164 : }
6165 :
6166 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6167 :
6168 0 : tevent_req_received(req);
6169 0 : return NT_STATUS_OK;
6170 : }
6171 :
6172 0 : NTSTATUS dcerpc_clusapi_DeleteResourceType_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteResourceType *r)
6173 : {
6174 : NTSTATUS status;
6175 :
6176 0 : status = dcerpc_binding_handle_call(h,
6177 : NULL, &ndr_table_clusapi,
6178 : NDR_CLUSAPI_DELETERESOURCETYPE, mem_ctx, r);
6179 :
6180 0 : return status;
6181 : }
6182 :
6183 : struct dcerpc_clusapi_DeleteResourceType_state {
6184 : struct clusapi_DeleteResourceType orig;
6185 : struct clusapi_DeleteResourceType tmp;
6186 : TALLOC_CTX *out_mem_ctx;
6187 : };
6188 :
6189 : static void dcerpc_clusapi_DeleteResourceType_done(struct tevent_req *subreq);
6190 :
6191 0 : struct tevent_req *dcerpc_clusapi_DeleteResourceType_send(TALLOC_CTX *mem_ctx,
6192 : struct tevent_context *ev,
6193 : struct dcerpc_binding_handle *h,
6194 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
6195 : WERROR *_rpc_status /* [out] [ref] */)
6196 : {
6197 : struct tevent_req *req;
6198 : struct dcerpc_clusapi_DeleteResourceType_state *state;
6199 : struct tevent_req *subreq;
6200 :
6201 0 : req = tevent_req_create(mem_ctx, &state,
6202 : struct dcerpc_clusapi_DeleteResourceType_state);
6203 0 : if (req == NULL) {
6204 0 : return NULL;
6205 : }
6206 0 : state->out_mem_ctx = NULL;
6207 :
6208 : /* In parameters */
6209 0 : state->orig.in.lpszTypeName = _lpszTypeName;
6210 :
6211 : /* Out parameters */
6212 0 : state->orig.out.rpc_status = _rpc_status;
6213 :
6214 : /* Result */
6215 0 : NDR_ZERO_STRUCT(state->orig.out.result);
6216 :
6217 0 : state->out_mem_ctx = talloc_named_const(state, 0,
6218 : "dcerpc_clusapi_DeleteResourceType_out_memory");
6219 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6220 0 : return tevent_req_post(req, ev);
6221 : }
6222 :
6223 : /* make a temporary copy, that we pass to the dispatch function */
6224 0 : state->tmp = state->orig;
6225 :
6226 0 : subreq = dcerpc_clusapi_DeleteResourceType_r_send(state, ev, h, &state->tmp);
6227 0 : if (tevent_req_nomem(subreq, req)) {
6228 0 : return tevent_req_post(req, ev);
6229 : }
6230 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteResourceType_done, req);
6231 0 : return req;
6232 : }
6233 :
6234 0 : static void dcerpc_clusapi_DeleteResourceType_done(struct tevent_req *subreq)
6235 : {
6236 0 : struct tevent_req *req = tevent_req_callback_data(
6237 : subreq, struct tevent_req);
6238 0 : struct dcerpc_clusapi_DeleteResourceType_state *state = tevent_req_data(
6239 : req, struct dcerpc_clusapi_DeleteResourceType_state);
6240 : NTSTATUS status;
6241 : TALLOC_CTX *mem_ctx;
6242 :
6243 0 : if (state->out_mem_ctx) {
6244 0 : mem_ctx = state->out_mem_ctx;
6245 : } else {
6246 0 : mem_ctx = state;
6247 : }
6248 :
6249 0 : status = dcerpc_clusapi_DeleteResourceType_r_recv(subreq, mem_ctx);
6250 0 : TALLOC_FREE(subreq);
6251 0 : if (tevent_req_nterror(req, status)) {
6252 0 : return;
6253 : }
6254 :
6255 : /* Copy out parameters */
6256 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
6257 :
6258 : /* Copy result */
6259 0 : state->orig.out.result = state->tmp.out.result;
6260 :
6261 : /* Reset temporary structure */
6262 0 : NDR_ZERO_STRUCT(state->tmp);
6263 :
6264 0 : tevent_req_done(req);
6265 : }
6266 :
6267 0 : NTSTATUS dcerpc_clusapi_DeleteResourceType_recv(struct tevent_req *req,
6268 : TALLOC_CTX *mem_ctx,
6269 : WERROR *result)
6270 : {
6271 0 : struct dcerpc_clusapi_DeleteResourceType_state *state = tevent_req_data(
6272 : req, struct dcerpc_clusapi_DeleteResourceType_state);
6273 : NTSTATUS status;
6274 :
6275 0 : if (tevent_req_is_nterror(req, &status)) {
6276 0 : tevent_req_received(req);
6277 0 : return status;
6278 : }
6279 :
6280 : /* Steal possible out parameters to the callers context */
6281 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6282 :
6283 : /* Return result */
6284 0 : *result = state->orig.out.result;
6285 :
6286 0 : tevent_req_received(req);
6287 0 : return NT_STATUS_OK;
6288 : }
6289 :
6290 0 : NTSTATUS dcerpc_clusapi_DeleteResourceType(struct dcerpc_binding_handle *h,
6291 : TALLOC_CTX *mem_ctx,
6292 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
6293 : WERROR *_rpc_status /* [out] [ref] */,
6294 : WERROR *result)
6295 : {
6296 : struct clusapi_DeleteResourceType r;
6297 : NTSTATUS status;
6298 :
6299 : /* In parameters */
6300 0 : r.in.lpszTypeName = _lpszTypeName;
6301 :
6302 : /* Out parameters */
6303 0 : r.out.rpc_status = _rpc_status;
6304 :
6305 : /* Result */
6306 0 : NDR_ZERO_STRUCT(r.out.result);
6307 :
6308 0 : status = dcerpc_clusapi_DeleteResourceType_r(h, mem_ctx, &r);
6309 0 : if (!NT_STATUS_IS_OK(status)) {
6310 0 : return status;
6311 : }
6312 :
6313 : /* Return variables */
6314 0 : *_rpc_status = *r.out.rpc_status;
6315 :
6316 : /* Return result */
6317 0 : *result = r.out.result;
6318 :
6319 0 : return NT_STATUS_OK;
6320 : }
6321 :
6322 : struct dcerpc_clusapi_GetRootKey_r_state {
6323 : TALLOC_CTX *out_mem_ctx;
6324 : };
6325 :
6326 : static void dcerpc_clusapi_GetRootKey_r_done(struct tevent_req *subreq);
6327 :
6328 0 : struct tevent_req *dcerpc_clusapi_GetRootKey_r_send(TALLOC_CTX *mem_ctx,
6329 : struct tevent_context *ev,
6330 : struct dcerpc_binding_handle *h,
6331 : struct clusapi_GetRootKey *r)
6332 : {
6333 : struct tevent_req *req;
6334 : struct dcerpc_clusapi_GetRootKey_r_state *state;
6335 : struct tevent_req *subreq;
6336 :
6337 0 : req = tevent_req_create(mem_ctx, &state,
6338 : struct dcerpc_clusapi_GetRootKey_r_state);
6339 0 : if (req == NULL) {
6340 0 : return NULL;
6341 : }
6342 :
6343 0 : state->out_mem_ctx = talloc_new(state);
6344 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6345 0 : return tevent_req_post(req, ev);
6346 : }
6347 :
6348 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
6349 : NULL, &ndr_table_clusapi,
6350 0 : NDR_CLUSAPI_GETROOTKEY, state->out_mem_ctx, r);
6351 0 : if (tevent_req_nomem(subreq, req)) {
6352 0 : return tevent_req_post(req, ev);
6353 : }
6354 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetRootKey_r_done, req);
6355 :
6356 0 : return req;
6357 : }
6358 :
6359 0 : static void dcerpc_clusapi_GetRootKey_r_done(struct tevent_req *subreq)
6360 : {
6361 0 : struct tevent_req *req =
6362 0 : tevent_req_callback_data(subreq,
6363 : struct tevent_req);
6364 : NTSTATUS status;
6365 :
6366 0 : status = dcerpc_binding_handle_call_recv(subreq);
6367 0 : TALLOC_FREE(subreq);
6368 0 : if (tevent_req_nterror(req, status)) {
6369 0 : return;
6370 : }
6371 :
6372 0 : tevent_req_done(req);
6373 : }
6374 :
6375 0 : NTSTATUS dcerpc_clusapi_GetRootKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6376 : {
6377 0 : struct dcerpc_clusapi_GetRootKey_r_state *state =
6378 0 : tevent_req_data(req,
6379 : struct dcerpc_clusapi_GetRootKey_r_state);
6380 : NTSTATUS status;
6381 :
6382 0 : if (tevent_req_is_nterror(req, &status)) {
6383 0 : tevent_req_received(req);
6384 0 : return status;
6385 : }
6386 :
6387 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6388 :
6389 0 : tevent_req_received(req);
6390 0 : return NT_STATUS_OK;
6391 : }
6392 :
6393 0 : NTSTATUS dcerpc_clusapi_GetRootKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetRootKey *r)
6394 : {
6395 : NTSTATUS status;
6396 :
6397 0 : status = dcerpc_binding_handle_call(h,
6398 : NULL, &ndr_table_clusapi,
6399 : NDR_CLUSAPI_GETROOTKEY, mem_ctx, r);
6400 :
6401 0 : return status;
6402 : }
6403 :
6404 : struct dcerpc_clusapi_GetRootKey_state {
6405 : struct clusapi_GetRootKey orig;
6406 : struct clusapi_GetRootKey tmp;
6407 : TALLOC_CTX *out_mem_ctx;
6408 : };
6409 :
6410 : static void dcerpc_clusapi_GetRootKey_done(struct tevent_req *subreq);
6411 :
6412 0 : struct tevent_req *dcerpc_clusapi_GetRootKey_send(TALLOC_CTX *mem_ctx,
6413 : struct tevent_context *ev,
6414 : struct dcerpc_binding_handle *h,
6415 : uint32_t _samDesired /* [in] */,
6416 : WERROR *_Status /* [out] [ref] */,
6417 : WERROR *_rpc_status /* [out] [ref] */,
6418 : struct policy_handle *_phKey /* [out] [ref] */)
6419 : {
6420 : struct tevent_req *req;
6421 : struct dcerpc_clusapi_GetRootKey_state *state;
6422 : struct tevent_req *subreq;
6423 :
6424 0 : req = tevent_req_create(mem_ctx, &state,
6425 : struct dcerpc_clusapi_GetRootKey_state);
6426 0 : if (req == NULL) {
6427 0 : return NULL;
6428 : }
6429 0 : state->out_mem_ctx = NULL;
6430 :
6431 : /* In parameters */
6432 0 : state->orig.in.samDesired = _samDesired;
6433 :
6434 : /* Out parameters */
6435 0 : state->orig.out.Status = _Status;
6436 0 : state->orig.out.rpc_status = _rpc_status;
6437 0 : state->orig.out.phKey = _phKey;
6438 :
6439 0 : state->out_mem_ctx = talloc_named_const(state, 0,
6440 : "dcerpc_clusapi_GetRootKey_out_memory");
6441 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6442 0 : return tevent_req_post(req, ev);
6443 : }
6444 :
6445 : /* make a temporary copy, that we pass to the dispatch function */
6446 0 : state->tmp = state->orig;
6447 :
6448 0 : subreq = dcerpc_clusapi_GetRootKey_r_send(state, ev, h, &state->tmp);
6449 0 : if (tevent_req_nomem(subreq, req)) {
6450 0 : return tevent_req_post(req, ev);
6451 : }
6452 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetRootKey_done, req);
6453 0 : return req;
6454 : }
6455 :
6456 0 : static void dcerpc_clusapi_GetRootKey_done(struct tevent_req *subreq)
6457 : {
6458 0 : struct tevent_req *req = tevent_req_callback_data(
6459 : subreq, struct tevent_req);
6460 0 : struct dcerpc_clusapi_GetRootKey_state *state = tevent_req_data(
6461 : req, struct dcerpc_clusapi_GetRootKey_state);
6462 : NTSTATUS status;
6463 : TALLOC_CTX *mem_ctx;
6464 :
6465 0 : if (state->out_mem_ctx) {
6466 0 : mem_ctx = state->out_mem_ctx;
6467 : } else {
6468 0 : mem_ctx = state;
6469 : }
6470 :
6471 0 : status = dcerpc_clusapi_GetRootKey_r_recv(subreq, mem_ctx);
6472 0 : TALLOC_FREE(subreq);
6473 0 : if (tevent_req_nterror(req, status)) {
6474 0 : return;
6475 : }
6476 :
6477 : /* Copy out parameters */
6478 0 : *state->orig.out.Status = *state->tmp.out.Status;
6479 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
6480 0 : *state->orig.out.phKey = *state->tmp.out.phKey;
6481 :
6482 : /* Reset temporary structure */
6483 0 : NDR_ZERO_STRUCT(state->tmp);
6484 :
6485 0 : tevent_req_done(req);
6486 : }
6487 :
6488 0 : NTSTATUS dcerpc_clusapi_GetRootKey_recv(struct tevent_req *req,
6489 : TALLOC_CTX *mem_ctx)
6490 : {
6491 0 : struct dcerpc_clusapi_GetRootKey_state *state = tevent_req_data(
6492 : req, struct dcerpc_clusapi_GetRootKey_state);
6493 : NTSTATUS status;
6494 :
6495 0 : if (tevent_req_is_nterror(req, &status)) {
6496 0 : tevent_req_received(req);
6497 0 : return status;
6498 : }
6499 :
6500 : /* Steal possible out parameters to the callers context */
6501 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6502 :
6503 0 : tevent_req_received(req);
6504 0 : return NT_STATUS_OK;
6505 : }
6506 :
6507 0 : NTSTATUS dcerpc_clusapi_GetRootKey(struct dcerpc_binding_handle *h,
6508 : TALLOC_CTX *mem_ctx,
6509 : uint32_t _samDesired /* [in] */,
6510 : WERROR *_Status /* [out] [ref] */,
6511 : WERROR *_rpc_status /* [out] [ref] */,
6512 : struct policy_handle *_phKey /* [out] [ref] */)
6513 : {
6514 : struct clusapi_GetRootKey r;
6515 : NTSTATUS status;
6516 :
6517 : /* In parameters */
6518 0 : r.in.samDesired = _samDesired;
6519 :
6520 : /* Out parameters */
6521 0 : r.out.Status = _Status;
6522 0 : r.out.rpc_status = _rpc_status;
6523 0 : r.out.phKey = _phKey;
6524 :
6525 0 : status = dcerpc_clusapi_GetRootKey_r(h, mem_ctx, &r);
6526 0 : if (!NT_STATUS_IS_OK(status)) {
6527 0 : return status;
6528 : }
6529 :
6530 : /* Return variables */
6531 0 : *_Status = *r.out.Status;
6532 0 : *_rpc_status = *r.out.rpc_status;
6533 0 : *_phKey = *r.out.phKey;
6534 :
6535 : /* Return result */
6536 :
6537 0 : return NT_STATUS_OK;
6538 : }
6539 :
6540 : struct dcerpc_clusapi_CreateKey_r_state {
6541 : TALLOC_CTX *out_mem_ctx;
6542 : };
6543 :
6544 : static void dcerpc_clusapi_CreateKey_r_done(struct tevent_req *subreq);
6545 :
6546 0 : struct tevent_req *dcerpc_clusapi_CreateKey_r_send(TALLOC_CTX *mem_ctx,
6547 : struct tevent_context *ev,
6548 : struct dcerpc_binding_handle *h,
6549 : struct clusapi_CreateKey *r)
6550 : {
6551 : struct tevent_req *req;
6552 : struct dcerpc_clusapi_CreateKey_r_state *state;
6553 : struct tevent_req *subreq;
6554 :
6555 0 : req = tevent_req_create(mem_ctx, &state,
6556 : struct dcerpc_clusapi_CreateKey_r_state);
6557 0 : if (req == NULL) {
6558 0 : return NULL;
6559 : }
6560 :
6561 0 : state->out_mem_ctx = talloc_new(state);
6562 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6563 0 : return tevent_req_post(req, ev);
6564 : }
6565 :
6566 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
6567 : NULL, &ndr_table_clusapi,
6568 0 : NDR_CLUSAPI_CREATEKEY, state->out_mem_ctx, r);
6569 0 : if (tevent_req_nomem(subreq, req)) {
6570 0 : return tevent_req_post(req, ev);
6571 : }
6572 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateKey_r_done, req);
6573 :
6574 0 : return req;
6575 : }
6576 :
6577 0 : static void dcerpc_clusapi_CreateKey_r_done(struct tevent_req *subreq)
6578 : {
6579 0 : struct tevent_req *req =
6580 0 : tevent_req_callback_data(subreq,
6581 : struct tevent_req);
6582 : NTSTATUS status;
6583 :
6584 0 : status = dcerpc_binding_handle_call_recv(subreq);
6585 0 : TALLOC_FREE(subreq);
6586 0 : if (tevent_req_nterror(req, status)) {
6587 0 : return;
6588 : }
6589 :
6590 0 : tevent_req_done(req);
6591 : }
6592 :
6593 0 : NTSTATUS dcerpc_clusapi_CreateKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6594 : {
6595 0 : struct dcerpc_clusapi_CreateKey_r_state *state =
6596 0 : tevent_req_data(req,
6597 : struct dcerpc_clusapi_CreateKey_r_state);
6598 : NTSTATUS status;
6599 :
6600 0 : if (tevent_req_is_nterror(req, &status)) {
6601 0 : tevent_req_received(req);
6602 0 : return status;
6603 : }
6604 :
6605 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6606 :
6607 0 : tevent_req_received(req);
6608 0 : return NT_STATUS_OK;
6609 : }
6610 :
6611 0 : NTSTATUS dcerpc_clusapi_CreateKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateKey *r)
6612 : {
6613 : NTSTATUS status;
6614 :
6615 0 : status = dcerpc_binding_handle_call(h,
6616 : NULL, &ndr_table_clusapi,
6617 : NDR_CLUSAPI_CREATEKEY, mem_ctx, r);
6618 :
6619 0 : return status;
6620 : }
6621 :
6622 : struct dcerpc_clusapi_CreateKey_state {
6623 : struct clusapi_CreateKey orig;
6624 : struct clusapi_CreateKey tmp;
6625 : TALLOC_CTX *out_mem_ctx;
6626 : };
6627 :
6628 : static void dcerpc_clusapi_CreateKey_done(struct tevent_req *subreq);
6629 :
6630 0 : struct tevent_req *dcerpc_clusapi_CreateKey_send(TALLOC_CTX *mem_ctx,
6631 : struct tevent_context *ev,
6632 : struct dcerpc_binding_handle *h,
6633 : struct policy_handle _hKey /* [in] */,
6634 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
6635 : uint32_t _dwOptions /* [in] */,
6636 : uint32_t _samDesired /* [in] */,
6637 : struct RPC_SECURITY_ATTRIBUTES *_lpSecurityAttributes /* [in] [unique] */,
6638 : uint32_t *_lpdwDisposition /* [out] [ref] */,
6639 : WERROR *_Status /* [out] [ref] */,
6640 : WERROR *_rpc_status /* [out] [ref] */,
6641 : struct policy_handle *_phKey /* [out] [ref] */)
6642 : {
6643 : struct tevent_req *req;
6644 : struct dcerpc_clusapi_CreateKey_state *state;
6645 : struct tevent_req *subreq;
6646 :
6647 0 : req = tevent_req_create(mem_ctx, &state,
6648 : struct dcerpc_clusapi_CreateKey_state);
6649 0 : if (req == NULL) {
6650 0 : return NULL;
6651 : }
6652 0 : state->out_mem_ctx = NULL;
6653 :
6654 : /* In parameters */
6655 0 : state->orig.in.hKey = _hKey;
6656 0 : state->orig.in.lpSubKey = _lpSubKey;
6657 0 : state->orig.in.dwOptions = _dwOptions;
6658 0 : state->orig.in.samDesired = _samDesired;
6659 0 : state->orig.in.lpSecurityAttributes = _lpSecurityAttributes;
6660 :
6661 : /* Out parameters */
6662 0 : state->orig.out.lpdwDisposition = _lpdwDisposition;
6663 0 : state->orig.out.Status = _Status;
6664 0 : state->orig.out.rpc_status = _rpc_status;
6665 0 : state->orig.out.phKey = _phKey;
6666 :
6667 0 : state->out_mem_ctx = talloc_named_const(state, 0,
6668 : "dcerpc_clusapi_CreateKey_out_memory");
6669 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6670 0 : return tevent_req_post(req, ev);
6671 : }
6672 :
6673 : /* make a temporary copy, that we pass to the dispatch function */
6674 0 : state->tmp = state->orig;
6675 :
6676 0 : subreq = dcerpc_clusapi_CreateKey_r_send(state, ev, h, &state->tmp);
6677 0 : if (tevent_req_nomem(subreq, req)) {
6678 0 : return tevent_req_post(req, ev);
6679 : }
6680 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateKey_done, req);
6681 0 : return req;
6682 : }
6683 :
6684 0 : static void dcerpc_clusapi_CreateKey_done(struct tevent_req *subreq)
6685 : {
6686 0 : struct tevent_req *req = tevent_req_callback_data(
6687 : subreq, struct tevent_req);
6688 0 : struct dcerpc_clusapi_CreateKey_state *state = tevent_req_data(
6689 : req, struct dcerpc_clusapi_CreateKey_state);
6690 : NTSTATUS status;
6691 : TALLOC_CTX *mem_ctx;
6692 :
6693 0 : if (state->out_mem_ctx) {
6694 0 : mem_ctx = state->out_mem_ctx;
6695 : } else {
6696 0 : mem_ctx = state;
6697 : }
6698 :
6699 0 : status = dcerpc_clusapi_CreateKey_r_recv(subreq, mem_ctx);
6700 0 : TALLOC_FREE(subreq);
6701 0 : if (tevent_req_nterror(req, status)) {
6702 0 : return;
6703 : }
6704 :
6705 : /* Copy out parameters */
6706 0 : *state->orig.out.lpdwDisposition = *state->tmp.out.lpdwDisposition;
6707 0 : *state->orig.out.Status = *state->tmp.out.Status;
6708 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
6709 0 : *state->orig.out.phKey = *state->tmp.out.phKey;
6710 :
6711 : /* Reset temporary structure */
6712 0 : NDR_ZERO_STRUCT(state->tmp);
6713 :
6714 0 : tevent_req_done(req);
6715 : }
6716 :
6717 0 : NTSTATUS dcerpc_clusapi_CreateKey_recv(struct tevent_req *req,
6718 : TALLOC_CTX *mem_ctx)
6719 : {
6720 0 : struct dcerpc_clusapi_CreateKey_state *state = tevent_req_data(
6721 : req, struct dcerpc_clusapi_CreateKey_state);
6722 : NTSTATUS status;
6723 :
6724 0 : if (tevent_req_is_nterror(req, &status)) {
6725 0 : tevent_req_received(req);
6726 0 : return status;
6727 : }
6728 :
6729 : /* Steal possible out parameters to the callers context */
6730 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6731 :
6732 0 : tevent_req_received(req);
6733 0 : return NT_STATUS_OK;
6734 : }
6735 :
6736 0 : NTSTATUS dcerpc_clusapi_CreateKey(struct dcerpc_binding_handle *h,
6737 : TALLOC_CTX *mem_ctx,
6738 : struct policy_handle _hKey /* [in] */,
6739 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
6740 : uint32_t _dwOptions /* [in] */,
6741 : uint32_t _samDesired /* [in] */,
6742 : struct RPC_SECURITY_ATTRIBUTES *_lpSecurityAttributes /* [in] [unique] */,
6743 : uint32_t *_lpdwDisposition /* [out] [ref] */,
6744 : WERROR *_Status /* [out] [ref] */,
6745 : WERROR *_rpc_status /* [out] [ref] */,
6746 : struct policy_handle *_phKey /* [out] [ref] */)
6747 : {
6748 : struct clusapi_CreateKey r;
6749 : NTSTATUS status;
6750 :
6751 : /* In parameters */
6752 0 : r.in.hKey = _hKey;
6753 0 : r.in.lpSubKey = _lpSubKey;
6754 0 : r.in.dwOptions = _dwOptions;
6755 0 : r.in.samDesired = _samDesired;
6756 0 : r.in.lpSecurityAttributes = _lpSecurityAttributes;
6757 :
6758 : /* Out parameters */
6759 0 : r.out.lpdwDisposition = _lpdwDisposition;
6760 0 : r.out.Status = _Status;
6761 0 : r.out.rpc_status = _rpc_status;
6762 0 : r.out.phKey = _phKey;
6763 :
6764 0 : status = dcerpc_clusapi_CreateKey_r(h, mem_ctx, &r);
6765 0 : if (!NT_STATUS_IS_OK(status)) {
6766 0 : return status;
6767 : }
6768 :
6769 : /* Return variables */
6770 0 : *_lpdwDisposition = *r.out.lpdwDisposition;
6771 0 : *_Status = *r.out.Status;
6772 0 : *_rpc_status = *r.out.rpc_status;
6773 0 : *_phKey = *r.out.phKey;
6774 :
6775 : /* Return result */
6776 :
6777 0 : return NT_STATUS_OK;
6778 : }
6779 :
6780 : struct dcerpc_clusapi_OpenKey_r_state {
6781 : TALLOC_CTX *out_mem_ctx;
6782 : };
6783 :
6784 : static void dcerpc_clusapi_OpenKey_r_done(struct tevent_req *subreq);
6785 :
6786 0 : struct tevent_req *dcerpc_clusapi_OpenKey_r_send(TALLOC_CTX *mem_ctx,
6787 : struct tevent_context *ev,
6788 : struct dcerpc_binding_handle *h,
6789 : struct clusapi_OpenKey *r)
6790 : {
6791 : struct tevent_req *req;
6792 : struct dcerpc_clusapi_OpenKey_r_state *state;
6793 : struct tevent_req *subreq;
6794 :
6795 0 : req = tevent_req_create(mem_ctx, &state,
6796 : struct dcerpc_clusapi_OpenKey_r_state);
6797 0 : if (req == NULL) {
6798 0 : return NULL;
6799 : }
6800 :
6801 0 : state->out_mem_ctx = talloc_new(state);
6802 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6803 0 : return tevent_req_post(req, ev);
6804 : }
6805 :
6806 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
6807 : NULL, &ndr_table_clusapi,
6808 0 : NDR_CLUSAPI_OPENKEY, state->out_mem_ctx, r);
6809 0 : if (tevent_req_nomem(subreq, req)) {
6810 0 : return tevent_req_post(req, ev);
6811 : }
6812 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenKey_r_done, req);
6813 :
6814 0 : return req;
6815 : }
6816 :
6817 0 : static void dcerpc_clusapi_OpenKey_r_done(struct tevent_req *subreq)
6818 : {
6819 0 : struct tevent_req *req =
6820 0 : tevent_req_callback_data(subreq,
6821 : struct tevent_req);
6822 : NTSTATUS status;
6823 :
6824 0 : status = dcerpc_binding_handle_call_recv(subreq);
6825 0 : TALLOC_FREE(subreq);
6826 0 : if (tevent_req_nterror(req, status)) {
6827 0 : return;
6828 : }
6829 :
6830 0 : tevent_req_done(req);
6831 : }
6832 :
6833 0 : NTSTATUS dcerpc_clusapi_OpenKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6834 : {
6835 0 : struct dcerpc_clusapi_OpenKey_r_state *state =
6836 0 : tevent_req_data(req,
6837 : struct dcerpc_clusapi_OpenKey_r_state);
6838 : NTSTATUS status;
6839 :
6840 0 : if (tevent_req_is_nterror(req, &status)) {
6841 0 : tevent_req_received(req);
6842 0 : return status;
6843 : }
6844 :
6845 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6846 :
6847 0 : tevent_req_received(req);
6848 0 : return NT_STATUS_OK;
6849 : }
6850 :
6851 0 : NTSTATUS dcerpc_clusapi_OpenKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenKey *r)
6852 : {
6853 : NTSTATUS status;
6854 :
6855 0 : status = dcerpc_binding_handle_call(h,
6856 : NULL, &ndr_table_clusapi,
6857 : NDR_CLUSAPI_OPENKEY, mem_ctx, r);
6858 :
6859 0 : return status;
6860 : }
6861 :
6862 : struct dcerpc_clusapi_OpenKey_state {
6863 : struct clusapi_OpenKey orig;
6864 : struct clusapi_OpenKey tmp;
6865 : TALLOC_CTX *out_mem_ctx;
6866 : };
6867 :
6868 : static void dcerpc_clusapi_OpenKey_done(struct tevent_req *subreq);
6869 :
6870 0 : struct tevent_req *dcerpc_clusapi_OpenKey_send(TALLOC_CTX *mem_ctx,
6871 : struct tevent_context *ev,
6872 : struct dcerpc_binding_handle *h,
6873 : struct policy_handle _hKey /* [in] */,
6874 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
6875 : uint32_t _samDesired /* [in] */,
6876 : WERROR *_Status /* [out] [ref] */,
6877 : WERROR *_rpc_status /* [out] [ref] */,
6878 : struct policy_handle *_phKey /* [out] [ref] */)
6879 : {
6880 : struct tevent_req *req;
6881 : struct dcerpc_clusapi_OpenKey_state *state;
6882 : struct tevent_req *subreq;
6883 :
6884 0 : req = tevent_req_create(mem_ctx, &state,
6885 : struct dcerpc_clusapi_OpenKey_state);
6886 0 : if (req == NULL) {
6887 0 : return NULL;
6888 : }
6889 0 : state->out_mem_ctx = NULL;
6890 :
6891 : /* In parameters */
6892 0 : state->orig.in.hKey = _hKey;
6893 0 : state->orig.in.lpSubKey = _lpSubKey;
6894 0 : state->orig.in.samDesired = _samDesired;
6895 :
6896 : /* Out parameters */
6897 0 : state->orig.out.Status = _Status;
6898 0 : state->orig.out.rpc_status = _rpc_status;
6899 0 : state->orig.out.phKey = _phKey;
6900 :
6901 0 : state->out_mem_ctx = talloc_named_const(state, 0,
6902 : "dcerpc_clusapi_OpenKey_out_memory");
6903 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
6904 0 : return tevent_req_post(req, ev);
6905 : }
6906 :
6907 : /* make a temporary copy, that we pass to the dispatch function */
6908 0 : state->tmp = state->orig;
6909 :
6910 0 : subreq = dcerpc_clusapi_OpenKey_r_send(state, ev, h, &state->tmp);
6911 0 : if (tevent_req_nomem(subreq, req)) {
6912 0 : return tevent_req_post(req, ev);
6913 : }
6914 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenKey_done, req);
6915 0 : return req;
6916 : }
6917 :
6918 0 : static void dcerpc_clusapi_OpenKey_done(struct tevent_req *subreq)
6919 : {
6920 0 : struct tevent_req *req = tevent_req_callback_data(
6921 : subreq, struct tevent_req);
6922 0 : struct dcerpc_clusapi_OpenKey_state *state = tevent_req_data(
6923 : req, struct dcerpc_clusapi_OpenKey_state);
6924 : NTSTATUS status;
6925 : TALLOC_CTX *mem_ctx;
6926 :
6927 0 : if (state->out_mem_ctx) {
6928 0 : mem_ctx = state->out_mem_ctx;
6929 : } else {
6930 0 : mem_ctx = state;
6931 : }
6932 :
6933 0 : status = dcerpc_clusapi_OpenKey_r_recv(subreq, mem_ctx);
6934 0 : TALLOC_FREE(subreq);
6935 0 : if (tevent_req_nterror(req, status)) {
6936 0 : return;
6937 : }
6938 :
6939 : /* Copy out parameters */
6940 0 : *state->orig.out.Status = *state->tmp.out.Status;
6941 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
6942 0 : *state->orig.out.phKey = *state->tmp.out.phKey;
6943 :
6944 : /* Reset temporary structure */
6945 0 : NDR_ZERO_STRUCT(state->tmp);
6946 :
6947 0 : tevent_req_done(req);
6948 : }
6949 :
6950 0 : NTSTATUS dcerpc_clusapi_OpenKey_recv(struct tevent_req *req,
6951 : TALLOC_CTX *mem_ctx)
6952 : {
6953 0 : struct dcerpc_clusapi_OpenKey_state *state = tevent_req_data(
6954 : req, struct dcerpc_clusapi_OpenKey_state);
6955 : NTSTATUS status;
6956 :
6957 0 : if (tevent_req_is_nterror(req, &status)) {
6958 0 : tevent_req_received(req);
6959 0 : return status;
6960 : }
6961 :
6962 : /* Steal possible out parameters to the callers context */
6963 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
6964 :
6965 0 : tevent_req_received(req);
6966 0 : return NT_STATUS_OK;
6967 : }
6968 :
6969 0 : NTSTATUS dcerpc_clusapi_OpenKey(struct dcerpc_binding_handle *h,
6970 : TALLOC_CTX *mem_ctx,
6971 : struct policy_handle _hKey /* [in] */,
6972 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
6973 : uint32_t _samDesired /* [in] */,
6974 : WERROR *_Status /* [out] [ref] */,
6975 : WERROR *_rpc_status /* [out] [ref] */,
6976 : struct policy_handle *_phKey /* [out] [ref] */)
6977 : {
6978 : struct clusapi_OpenKey r;
6979 : NTSTATUS status;
6980 :
6981 : /* In parameters */
6982 0 : r.in.hKey = _hKey;
6983 0 : r.in.lpSubKey = _lpSubKey;
6984 0 : r.in.samDesired = _samDesired;
6985 :
6986 : /* Out parameters */
6987 0 : r.out.Status = _Status;
6988 0 : r.out.rpc_status = _rpc_status;
6989 0 : r.out.phKey = _phKey;
6990 :
6991 0 : status = dcerpc_clusapi_OpenKey_r(h, mem_ctx, &r);
6992 0 : if (!NT_STATUS_IS_OK(status)) {
6993 0 : return status;
6994 : }
6995 :
6996 : /* Return variables */
6997 0 : *_Status = *r.out.Status;
6998 0 : *_rpc_status = *r.out.rpc_status;
6999 0 : *_phKey = *r.out.phKey;
7000 :
7001 : /* Return result */
7002 :
7003 0 : return NT_STATUS_OK;
7004 : }
7005 :
7006 : struct dcerpc_clusapi_EnumKey_r_state {
7007 : TALLOC_CTX *out_mem_ctx;
7008 : };
7009 :
7010 : static void dcerpc_clusapi_EnumKey_r_done(struct tevent_req *subreq);
7011 :
7012 0 : struct tevent_req *dcerpc_clusapi_EnumKey_r_send(TALLOC_CTX *mem_ctx,
7013 : struct tevent_context *ev,
7014 : struct dcerpc_binding_handle *h,
7015 : struct clusapi_EnumKey *r)
7016 : {
7017 : struct tevent_req *req;
7018 : struct dcerpc_clusapi_EnumKey_r_state *state;
7019 : struct tevent_req *subreq;
7020 :
7021 0 : req = tevent_req_create(mem_ctx, &state,
7022 : struct dcerpc_clusapi_EnumKey_r_state);
7023 0 : if (req == NULL) {
7024 0 : return NULL;
7025 : }
7026 :
7027 0 : state->out_mem_ctx = talloc_new(state);
7028 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7029 0 : return tevent_req_post(req, ev);
7030 : }
7031 :
7032 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
7033 : NULL, &ndr_table_clusapi,
7034 0 : NDR_CLUSAPI_ENUMKEY, state->out_mem_ctx, r);
7035 0 : if (tevent_req_nomem(subreq, req)) {
7036 0 : return tevent_req_post(req, ev);
7037 : }
7038 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EnumKey_r_done, req);
7039 :
7040 0 : return req;
7041 : }
7042 :
7043 0 : static void dcerpc_clusapi_EnumKey_r_done(struct tevent_req *subreq)
7044 : {
7045 0 : struct tevent_req *req =
7046 0 : tevent_req_callback_data(subreq,
7047 : struct tevent_req);
7048 : NTSTATUS status;
7049 :
7050 0 : status = dcerpc_binding_handle_call_recv(subreq);
7051 0 : TALLOC_FREE(subreq);
7052 0 : if (tevent_req_nterror(req, status)) {
7053 0 : return;
7054 : }
7055 :
7056 0 : tevent_req_done(req);
7057 : }
7058 :
7059 0 : NTSTATUS dcerpc_clusapi_EnumKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7060 : {
7061 0 : struct dcerpc_clusapi_EnumKey_r_state *state =
7062 0 : tevent_req_data(req,
7063 : struct dcerpc_clusapi_EnumKey_r_state);
7064 : NTSTATUS status;
7065 :
7066 0 : if (tevent_req_is_nterror(req, &status)) {
7067 0 : tevent_req_received(req);
7068 0 : return status;
7069 : }
7070 :
7071 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7072 :
7073 0 : tevent_req_received(req);
7074 0 : return NT_STATUS_OK;
7075 : }
7076 :
7077 0 : NTSTATUS dcerpc_clusapi_EnumKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_EnumKey *r)
7078 : {
7079 : NTSTATUS status;
7080 :
7081 0 : status = dcerpc_binding_handle_call(h,
7082 : NULL, &ndr_table_clusapi,
7083 : NDR_CLUSAPI_ENUMKEY, mem_ctx, r);
7084 :
7085 0 : return status;
7086 : }
7087 :
7088 : struct dcerpc_clusapi_EnumKey_state {
7089 : struct clusapi_EnumKey orig;
7090 : struct clusapi_EnumKey tmp;
7091 : TALLOC_CTX *out_mem_ctx;
7092 : };
7093 :
7094 : static void dcerpc_clusapi_EnumKey_done(struct tevent_req *subreq);
7095 :
7096 0 : struct tevent_req *dcerpc_clusapi_EnumKey_send(TALLOC_CTX *mem_ctx,
7097 : struct tevent_context *ev,
7098 : struct dcerpc_binding_handle *h,
7099 : struct policy_handle _hKey /* [in] */,
7100 : uint32_t _dwIndex /* [in] */,
7101 : const char **_KeyName /* [out] [charset(UTF16),ref] */,
7102 : NTTIME *_lpftLastWriteTime /* [out] [ref] */,
7103 : WERROR *_rpc_status /* [out] [ref] */)
7104 : {
7105 : struct tevent_req *req;
7106 : struct dcerpc_clusapi_EnumKey_state *state;
7107 : struct tevent_req *subreq;
7108 :
7109 0 : req = tevent_req_create(mem_ctx, &state,
7110 : struct dcerpc_clusapi_EnumKey_state);
7111 0 : if (req == NULL) {
7112 0 : return NULL;
7113 : }
7114 0 : state->out_mem_ctx = NULL;
7115 :
7116 : /* In parameters */
7117 0 : state->orig.in.hKey = _hKey;
7118 0 : state->orig.in.dwIndex = _dwIndex;
7119 :
7120 : /* Out parameters */
7121 0 : state->orig.out.KeyName = _KeyName;
7122 0 : state->orig.out.lpftLastWriteTime = _lpftLastWriteTime;
7123 0 : state->orig.out.rpc_status = _rpc_status;
7124 :
7125 : /* Result */
7126 0 : NDR_ZERO_STRUCT(state->orig.out.result);
7127 :
7128 0 : state->out_mem_ctx = talloc_named_const(state, 0,
7129 : "dcerpc_clusapi_EnumKey_out_memory");
7130 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7131 0 : return tevent_req_post(req, ev);
7132 : }
7133 :
7134 : /* make a temporary copy, that we pass to the dispatch function */
7135 0 : state->tmp = state->orig;
7136 :
7137 0 : subreq = dcerpc_clusapi_EnumKey_r_send(state, ev, h, &state->tmp);
7138 0 : if (tevent_req_nomem(subreq, req)) {
7139 0 : return tevent_req_post(req, ev);
7140 : }
7141 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EnumKey_done, req);
7142 0 : return req;
7143 : }
7144 :
7145 0 : static void dcerpc_clusapi_EnumKey_done(struct tevent_req *subreq)
7146 : {
7147 0 : struct tevent_req *req = tevent_req_callback_data(
7148 : subreq, struct tevent_req);
7149 0 : struct dcerpc_clusapi_EnumKey_state *state = tevent_req_data(
7150 : req, struct dcerpc_clusapi_EnumKey_state);
7151 : NTSTATUS status;
7152 : TALLOC_CTX *mem_ctx;
7153 :
7154 0 : if (state->out_mem_ctx) {
7155 0 : mem_ctx = state->out_mem_ctx;
7156 : } else {
7157 0 : mem_ctx = state;
7158 : }
7159 :
7160 0 : status = dcerpc_clusapi_EnumKey_r_recv(subreq, mem_ctx);
7161 0 : TALLOC_FREE(subreq);
7162 0 : if (tevent_req_nterror(req, status)) {
7163 0 : return;
7164 : }
7165 :
7166 : /* Copy out parameters */
7167 0 : *state->orig.out.KeyName = *state->tmp.out.KeyName;
7168 0 : *state->orig.out.lpftLastWriteTime = *state->tmp.out.lpftLastWriteTime;
7169 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
7170 :
7171 : /* Copy result */
7172 0 : state->orig.out.result = state->tmp.out.result;
7173 :
7174 : /* Reset temporary structure */
7175 0 : NDR_ZERO_STRUCT(state->tmp);
7176 :
7177 0 : tevent_req_done(req);
7178 : }
7179 :
7180 0 : NTSTATUS dcerpc_clusapi_EnumKey_recv(struct tevent_req *req,
7181 : TALLOC_CTX *mem_ctx,
7182 : WERROR *result)
7183 : {
7184 0 : struct dcerpc_clusapi_EnumKey_state *state = tevent_req_data(
7185 : req, struct dcerpc_clusapi_EnumKey_state);
7186 : NTSTATUS status;
7187 :
7188 0 : if (tevent_req_is_nterror(req, &status)) {
7189 0 : tevent_req_received(req);
7190 0 : return status;
7191 : }
7192 :
7193 : /* Steal possible out parameters to the callers context */
7194 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7195 :
7196 : /* Return result */
7197 0 : *result = state->orig.out.result;
7198 :
7199 0 : tevent_req_received(req);
7200 0 : return NT_STATUS_OK;
7201 : }
7202 :
7203 0 : NTSTATUS dcerpc_clusapi_EnumKey(struct dcerpc_binding_handle *h,
7204 : TALLOC_CTX *mem_ctx,
7205 : struct policy_handle _hKey /* [in] */,
7206 : uint32_t _dwIndex /* [in] */,
7207 : const char **_KeyName /* [out] [charset(UTF16),ref] */,
7208 : NTTIME *_lpftLastWriteTime /* [out] [ref] */,
7209 : WERROR *_rpc_status /* [out] [ref] */,
7210 : WERROR *result)
7211 : {
7212 : struct clusapi_EnumKey r;
7213 : NTSTATUS status;
7214 :
7215 : /* In parameters */
7216 0 : r.in.hKey = _hKey;
7217 0 : r.in.dwIndex = _dwIndex;
7218 :
7219 : /* Out parameters */
7220 0 : r.out.KeyName = _KeyName;
7221 0 : r.out.lpftLastWriteTime = _lpftLastWriteTime;
7222 0 : r.out.rpc_status = _rpc_status;
7223 :
7224 : /* Result */
7225 0 : NDR_ZERO_STRUCT(r.out.result);
7226 :
7227 0 : status = dcerpc_clusapi_EnumKey_r(h, mem_ctx, &r);
7228 0 : if (!NT_STATUS_IS_OK(status)) {
7229 0 : return status;
7230 : }
7231 :
7232 : /* Return variables */
7233 0 : *_KeyName = *r.out.KeyName;
7234 0 : *_lpftLastWriteTime = *r.out.lpftLastWriteTime;
7235 0 : *_rpc_status = *r.out.rpc_status;
7236 :
7237 : /* Return result */
7238 0 : *result = r.out.result;
7239 :
7240 0 : return NT_STATUS_OK;
7241 : }
7242 :
7243 : struct dcerpc_clusapi_SetValue_r_state {
7244 : TALLOC_CTX *out_mem_ctx;
7245 : };
7246 :
7247 : static void dcerpc_clusapi_SetValue_r_done(struct tevent_req *subreq);
7248 :
7249 0 : struct tevent_req *dcerpc_clusapi_SetValue_r_send(TALLOC_CTX *mem_ctx,
7250 : struct tevent_context *ev,
7251 : struct dcerpc_binding_handle *h,
7252 : struct clusapi_SetValue *r)
7253 : {
7254 : struct tevent_req *req;
7255 : struct dcerpc_clusapi_SetValue_r_state *state;
7256 : struct tevent_req *subreq;
7257 :
7258 0 : req = tevent_req_create(mem_ctx, &state,
7259 : struct dcerpc_clusapi_SetValue_r_state);
7260 0 : if (req == NULL) {
7261 0 : return NULL;
7262 : }
7263 :
7264 0 : state->out_mem_ctx = talloc_new(state);
7265 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7266 0 : return tevent_req_post(req, ev);
7267 : }
7268 :
7269 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
7270 : NULL, &ndr_table_clusapi,
7271 0 : NDR_CLUSAPI_SETVALUE, state->out_mem_ctx, r);
7272 0 : if (tevent_req_nomem(subreq, req)) {
7273 0 : return tevent_req_post(req, ev);
7274 : }
7275 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetValue_r_done, req);
7276 :
7277 0 : return req;
7278 : }
7279 :
7280 0 : static void dcerpc_clusapi_SetValue_r_done(struct tevent_req *subreq)
7281 : {
7282 0 : struct tevent_req *req =
7283 0 : tevent_req_callback_data(subreq,
7284 : struct tevent_req);
7285 : NTSTATUS status;
7286 :
7287 0 : status = dcerpc_binding_handle_call_recv(subreq);
7288 0 : TALLOC_FREE(subreq);
7289 0 : if (tevent_req_nterror(req, status)) {
7290 0 : return;
7291 : }
7292 :
7293 0 : tevent_req_done(req);
7294 : }
7295 :
7296 0 : NTSTATUS dcerpc_clusapi_SetValue_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7297 : {
7298 0 : struct dcerpc_clusapi_SetValue_r_state *state =
7299 0 : tevent_req_data(req,
7300 : struct dcerpc_clusapi_SetValue_r_state);
7301 : NTSTATUS status;
7302 :
7303 0 : if (tevent_req_is_nterror(req, &status)) {
7304 0 : tevent_req_received(req);
7305 0 : return status;
7306 : }
7307 :
7308 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7309 :
7310 0 : tevent_req_received(req);
7311 0 : return NT_STATUS_OK;
7312 : }
7313 :
7314 0 : NTSTATUS dcerpc_clusapi_SetValue_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetValue *r)
7315 : {
7316 : NTSTATUS status;
7317 :
7318 0 : status = dcerpc_binding_handle_call(h,
7319 : NULL, &ndr_table_clusapi,
7320 : NDR_CLUSAPI_SETVALUE, mem_ctx, r);
7321 :
7322 0 : return status;
7323 : }
7324 :
7325 : struct dcerpc_clusapi_SetValue_state {
7326 : struct clusapi_SetValue orig;
7327 : struct clusapi_SetValue tmp;
7328 : TALLOC_CTX *out_mem_ctx;
7329 : };
7330 :
7331 : static void dcerpc_clusapi_SetValue_done(struct tevent_req *subreq);
7332 :
7333 0 : struct tevent_req *dcerpc_clusapi_SetValue_send(TALLOC_CTX *mem_ctx,
7334 : struct tevent_context *ev,
7335 : struct dcerpc_binding_handle *h,
7336 : struct policy_handle _hKey /* [in] */,
7337 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7338 : enum winreg_Type _dwType /* [in] */,
7339 : uint8_t *_lpData /* [in] [ref,size_is(cbData)] */,
7340 : uint32_t _cbData /* [in] */,
7341 : WERROR *_rpc_status /* [out] [ref] */)
7342 : {
7343 : struct tevent_req *req;
7344 : struct dcerpc_clusapi_SetValue_state *state;
7345 : struct tevent_req *subreq;
7346 :
7347 0 : req = tevent_req_create(mem_ctx, &state,
7348 : struct dcerpc_clusapi_SetValue_state);
7349 0 : if (req == NULL) {
7350 0 : return NULL;
7351 : }
7352 0 : state->out_mem_ctx = NULL;
7353 :
7354 : /* In parameters */
7355 0 : state->orig.in.hKey = _hKey;
7356 0 : state->orig.in.lpValueName = _lpValueName;
7357 0 : state->orig.in.dwType = _dwType;
7358 0 : state->orig.in.lpData = _lpData;
7359 0 : state->orig.in.cbData = _cbData;
7360 :
7361 : /* Out parameters */
7362 0 : state->orig.out.rpc_status = _rpc_status;
7363 :
7364 : /* Result */
7365 0 : NDR_ZERO_STRUCT(state->orig.out.result);
7366 :
7367 0 : state->out_mem_ctx = talloc_named_const(state, 0,
7368 : "dcerpc_clusapi_SetValue_out_memory");
7369 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7370 0 : return tevent_req_post(req, ev);
7371 : }
7372 :
7373 : /* make a temporary copy, that we pass to the dispatch function */
7374 0 : state->tmp = state->orig;
7375 :
7376 0 : subreq = dcerpc_clusapi_SetValue_r_send(state, ev, h, &state->tmp);
7377 0 : if (tevent_req_nomem(subreq, req)) {
7378 0 : return tevent_req_post(req, ev);
7379 : }
7380 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetValue_done, req);
7381 0 : return req;
7382 : }
7383 :
7384 0 : static void dcerpc_clusapi_SetValue_done(struct tevent_req *subreq)
7385 : {
7386 0 : struct tevent_req *req = tevent_req_callback_data(
7387 : subreq, struct tevent_req);
7388 0 : struct dcerpc_clusapi_SetValue_state *state = tevent_req_data(
7389 : req, struct dcerpc_clusapi_SetValue_state);
7390 : NTSTATUS status;
7391 : TALLOC_CTX *mem_ctx;
7392 :
7393 0 : if (state->out_mem_ctx) {
7394 0 : mem_ctx = state->out_mem_ctx;
7395 : } else {
7396 0 : mem_ctx = state;
7397 : }
7398 :
7399 0 : status = dcerpc_clusapi_SetValue_r_recv(subreq, mem_ctx);
7400 0 : TALLOC_FREE(subreq);
7401 0 : if (tevent_req_nterror(req, status)) {
7402 0 : return;
7403 : }
7404 :
7405 : /* Copy out parameters */
7406 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
7407 :
7408 : /* Copy result */
7409 0 : state->orig.out.result = state->tmp.out.result;
7410 :
7411 : /* Reset temporary structure */
7412 0 : NDR_ZERO_STRUCT(state->tmp);
7413 :
7414 0 : tevent_req_done(req);
7415 : }
7416 :
7417 0 : NTSTATUS dcerpc_clusapi_SetValue_recv(struct tevent_req *req,
7418 : TALLOC_CTX *mem_ctx,
7419 : WERROR *result)
7420 : {
7421 0 : struct dcerpc_clusapi_SetValue_state *state = tevent_req_data(
7422 : req, struct dcerpc_clusapi_SetValue_state);
7423 : NTSTATUS status;
7424 :
7425 0 : if (tevent_req_is_nterror(req, &status)) {
7426 0 : tevent_req_received(req);
7427 0 : return status;
7428 : }
7429 :
7430 : /* Steal possible out parameters to the callers context */
7431 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7432 :
7433 : /* Return result */
7434 0 : *result = state->orig.out.result;
7435 :
7436 0 : tevent_req_received(req);
7437 0 : return NT_STATUS_OK;
7438 : }
7439 :
7440 0 : NTSTATUS dcerpc_clusapi_SetValue(struct dcerpc_binding_handle *h,
7441 : TALLOC_CTX *mem_ctx,
7442 : struct policy_handle _hKey /* [in] */,
7443 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7444 : enum winreg_Type _dwType /* [in] */,
7445 : uint8_t *_lpData /* [in] [ref,size_is(cbData)] */,
7446 : uint32_t _cbData /* [in] */,
7447 : WERROR *_rpc_status /* [out] [ref] */,
7448 : WERROR *result)
7449 : {
7450 : struct clusapi_SetValue r;
7451 : NTSTATUS status;
7452 :
7453 : /* In parameters */
7454 0 : r.in.hKey = _hKey;
7455 0 : r.in.lpValueName = _lpValueName;
7456 0 : r.in.dwType = _dwType;
7457 0 : r.in.lpData = _lpData;
7458 0 : r.in.cbData = _cbData;
7459 :
7460 : /* Out parameters */
7461 0 : r.out.rpc_status = _rpc_status;
7462 :
7463 : /* Result */
7464 0 : NDR_ZERO_STRUCT(r.out.result);
7465 :
7466 0 : status = dcerpc_clusapi_SetValue_r(h, mem_ctx, &r);
7467 0 : if (!NT_STATUS_IS_OK(status)) {
7468 0 : return status;
7469 : }
7470 :
7471 : /* Return variables */
7472 0 : *_rpc_status = *r.out.rpc_status;
7473 :
7474 : /* Return result */
7475 0 : *result = r.out.result;
7476 :
7477 0 : return NT_STATUS_OK;
7478 : }
7479 :
7480 : struct dcerpc_clusapi_DeleteValue_r_state {
7481 : TALLOC_CTX *out_mem_ctx;
7482 : };
7483 :
7484 : static void dcerpc_clusapi_DeleteValue_r_done(struct tevent_req *subreq);
7485 :
7486 0 : struct tevent_req *dcerpc_clusapi_DeleteValue_r_send(TALLOC_CTX *mem_ctx,
7487 : struct tevent_context *ev,
7488 : struct dcerpc_binding_handle *h,
7489 : struct clusapi_DeleteValue *r)
7490 : {
7491 : struct tevent_req *req;
7492 : struct dcerpc_clusapi_DeleteValue_r_state *state;
7493 : struct tevent_req *subreq;
7494 :
7495 0 : req = tevent_req_create(mem_ctx, &state,
7496 : struct dcerpc_clusapi_DeleteValue_r_state);
7497 0 : if (req == NULL) {
7498 0 : return NULL;
7499 : }
7500 :
7501 0 : state->out_mem_ctx = talloc_new(state);
7502 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7503 0 : return tevent_req_post(req, ev);
7504 : }
7505 :
7506 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
7507 : NULL, &ndr_table_clusapi,
7508 0 : NDR_CLUSAPI_DELETEVALUE, state->out_mem_ctx, r);
7509 0 : if (tevent_req_nomem(subreq, req)) {
7510 0 : return tevent_req_post(req, ev);
7511 : }
7512 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteValue_r_done, req);
7513 :
7514 0 : return req;
7515 : }
7516 :
7517 0 : static void dcerpc_clusapi_DeleteValue_r_done(struct tevent_req *subreq)
7518 : {
7519 0 : struct tevent_req *req =
7520 0 : tevent_req_callback_data(subreq,
7521 : struct tevent_req);
7522 : NTSTATUS status;
7523 :
7524 0 : status = dcerpc_binding_handle_call_recv(subreq);
7525 0 : TALLOC_FREE(subreq);
7526 0 : if (tevent_req_nterror(req, status)) {
7527 0 : return;
7528 : }
7529 :
7530 0 : tevent_req_done(req);
7531 : }
7532 :
7533 0 : NTSTATUS dcerpc_clusapi_DeleteValue_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7534 : {
7535 0 : struct dcerpc_clusapi_DeleteValue_r_state *state =
7536 0 : tevent_req_data(req,
7537 : struct dcerpc_clusapi_DeleteValue_r_state);
7538 : NTSTATUS status;
7539 :
7540 0 : if (tevent_req_is_nterror(req, &status)) {
7541 0 : tevent_req_received(req);
7542 0 : return status;
7543 : }
7544 :
7545 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7546 :
7547 0 : tevent_req_received(req);
7548 0 : return NT_STATUS_OK;
7549 : }
7550 :
7551 0 : NTSTATUS dcerpc_clusapi_DeleteValue_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteValue *r)
7552 : {
7553 : NTSTATUS status;
7554 :
7555 0 : status = dcerpc_binding_handle_call(h,
7556 : NULL, &ndr_table_clusapi,
7557 : NDR_CLUSAPI_DELETEVALUE, mem_ctx, r);
7558 :
7559 0 : return status;
7560 : }
7561 :
7562 : struct dcerpc_clusapi_DeleteValue_state {
7563 : struct clusapi_DeleteValue orig;
7564 : struct clusapi_DeleteValue tmp;
7565 : TALLOC_CTX *out_mem_ctx;
7566 : };
7567 :
7568 : static void dcerpc_clusapi_DeleteValue_done(struct tevent_req *subreq);
7569 :
7570 0 : struct tevent_req *dcerpc_clusapi_DeleteValue_send(TALLOC_CTX *mem_ctx,
7571 : struct tevent_context *ev,
7572 : struct dcerpc_binding_handle *h,
7573 : struct policy_handle _hKey /* [in] */,
7574 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7575 : WERROR *_rpc_status /* [out] [ref] */)
7576 : {
7577 : struct tevent_req *req;
7578 : struct dcerpc_clusapi_DeleteValue_state *state;
7579 : struct tevent_req *subreq;
7580 :
7581 0 : req = tevent_req_create(mem_ctx, &state,
7582 : struct dcerpc_clusapi_DeleteValue_state);
7583 0 : if (req == NULL) {
7584 0 : return NULL;
7585 : }
7586 0 : state->out_mem_ctx = NULL;
7587 :
7588 : /* In parameters */
7589 0 : state->orig.in.hKey = _hKey;
7590 0 : state->orig.in.lpValueName = _lpValueName;
7591 :
7592 : /* Out parameters */
7593 0 : state->orig.out.rpc_status = _rpc_status;
7594 :
7595 : /* Result */
7596 0 : NDR_ZERO_STRUCT(state->orig.out.result);
7597 :
7598 0 : state->out_mem_ctx = talloc_named_const(state, 0,
7599 : "dcerpc_clusapi_DeleteValue_out_memory");
7600 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7601 0 : return tevent_req_post(req, ev);
7602 : }
7603 :
7604 : /* make a temporary copy, that we pass to the dispatch function */
7605 0 : state->tmp = state->orig;
7606 :
7607 0 : subreq = dcerpc_clusapi_DeleteValue_r_send(state, ev, h, &state->tmp);
7608 0 : if (tevent_req_nomem(subreq, req)) {
7609 0 : return tevent_req_post(req, ev);
7610 : }
7611 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteValue_done, req);
7612 0 : return req;
7613 : }
7614 :
7615 0 : static void dcerpc_clusapi_DeleteValue_done(struct tevent_req *subreq)
7616 : {
7617 0 : struct tevent_req *req = tevent_req_callback_data(
7618 : subreq, struct tevent_req);
7619 0 : struct dcerpc_clusapi_DeleteValue_state *state = tevent_req_data(
7620 : req, struct dcerpc_clusapi_DeleteValue_state);
7621 : NTSTATUS status;
7622 : TALLOC_CTX *mem_ctx;
7623 :
7624 0 : if (state->out_mem_ctx) {
7625 0 : mem_ctx = state->out_mem_ctx;
7626 : } else {
7627 0 : mem_ctx = state;
7628 : }
7629 :
7630 0 : status = dcerpc_clusapi_DeleteValue_r_recv(subreq, mem_ctx);
7631 0 : TALLOC_FREE(subreq);
7632 0 : if (tevent_req_nterror(req, status)) {
7633 0 : return;
7634 : }
7635 :
7636 : /* Copy out parameters */
7637 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
7638 :
7639 : /* Copy result */
7640 0 : state->orig.out.result = state->tmp.out.result;
7641 :
7642 : /* Reset temporary structure */
7643 0 : NDR_ZERO_STRUCT(state->tmp);
7644 :
7645 0 : tevent_req_done(req);
7646 : }
7647 :
7648 0 : NTSTATUS dcerpc_clusapi_DeleteValue_recv(struct tevent_req *req,
7649 : TALLOC_CTX *mem_ctx,
7650 : WERROR *result)
7651 : {
7652 0 : struct dcerpc_clusapi_DeleteValue_state *state = tevent_req_data(
7653 : req, struct dcerpc_clusapi_DeleteValue_state);
7654 : NTSTATUS status;
7655 :
7656 0 : if (tevent_req_is_nterror(req, &status)) {
7657 0 : tevent_req_received(req);
7658 0 : return status;
7659 : }
7660 :
7661 : /* Steal possible out parameters to the callers context */
7662 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7663 :
7664 : /* Return result */
7665 0 : *result = state->orig.out.result;
7666 :
7667 0 : tevent_req_received(req);
7668 0 : return NT_STATUS_OK;
7669 : }
7670 :
7671 0 : NTSTATUS dcerpc_clusapi_DeleteValue(struct dcerpc_binding_handle *h,
7672 : TALLOC_CTX *mem_ctx,
7673 : struct policy_handle _hKey /* [in] */,
7674 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7675 : WERROR *_rpc_status /* [out] [ref] */,
7676 : WERROR *result)
7677 : {
7678 : struct clusapi_DeleteValue r;
7679 : NTSTATUS status;
7680 :
7681 : /* In parameters */
7682 0 : r.in.hKey = _hKey;
7683 0 : r.in.lpValueName = _lpValueName;
7684 :
7685 : /* Out parameters */
7686 0 : r.out.rpc_status = _rpc_status;
7687 :
7688 : /* Result */
7689 0 : NDR_ZERO_STRUCT(r.out.result);
7690 :
7691 0 : status = dcerpc_clusapi_DeleteValue_r(h, mem_ctx, &r);
7692 0 : if (!NT_STATUS_IS_OK(status)) {
7693 0 : return status;
7694 : }
7695 :
7696 : /* Return variables */
7697 0 : *_rpc_status = *r.out.rpc_status;
7698 :
7699 : /* Return result */
7700 0 : *result = r.out.result;
7701 :
7702 0 : return NT_STATUS_OK;
7703 : }
7704 :
7705 : struct dcerpc_clusapi_QueryValue_r_state {
7706 : TALLOC_CTX *out_mem_ctx;
7707 : };
7708 :
7709 : static void dcerpc_clusapi_QueryValue_r_done(struct tevent_req *subreq);
7710 :
7711 0 : struct tevent_req *dcerpc_clusapi_QueryValue_r_send(TALLOC_CTX *mem_ctx,
7712 : struct tevent_context *ev,
7713 : struct dcerpc_binding_handle *h,
7714 : struct clusapi_QueryValue *r)
7715 : {
7716 : struct tevent_req *req;
7717 : struct dcerpc_clusapi_QueryValue_r_state *state;
7718 : struct tevent_req *subreq;
7719 :
7720 0 : req = tevent_req_create(mem_ctx, &state,
7721 : struct dcerpc_clusapi_QueryValue_r_state);
7722 0 : if (req == NULL) {
7723 0 : return NULL;
7724 : }
7725 :
7726 0 : state->out_mem_ctx = talloc_new(state);
7727 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7728 0 : return tevent_req_post(req, ev);
7729 : }
7730 :
7731 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
7732 : NULL, &ndr_table_clusapi,
7733 0 : NDR_CLUSAPI_QUERYVALUE, state->out_mem_ctx, r);
7734 0 : if (tevent_req_nomem(subreq, req)) {
7735 0 : return tevent_req_post(req, ev);
7736 : }
7737 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryValue_r_done, req);
7738 :
7739 0 : return req;
7740 : }
7741 :
7742 0 : static void dcerpc_clusapi_QueryValue_r_done(struct tevent_req *subreq)
7743 : {
7744 0 : struct tevent_req *req =
7745 0 : tevent_req_callback_data(subreq,
7746 : struct tevent_req);
7747 : NTSTATUS status;
7748 :
7749 0 : status = dcerpc_binding_handle_call_recv(subreq);
7750 0 : TALLOC_FREE(subreq);
7751 0 : if (tevent_req_nterror(req, status)) {
7752 0 : return;
7753 : }
7754 :
7755 0 : tevent_req_done(req);
7756 : }
7757 :
7758 0 : NTSTATUS dcerpc_clusapi_QueryValue_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7759 : {
7760 0 : struct dcerpc_clusapi_QueryValue_r_state *state =
7761 0 : tevent_req_data(req,
7762 : struct dcerpc_clusapi_QueryValue_r_state);
7763 : NTSTATUS status;
7764 :
7765 0 : if (tevent_req_is_nterror(req, &status)) {
7766 0 : tevent_req_received(req);
7767 0 : return status;
7768 : }
7769 :
7770 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7771 :
7772 0 : tevent_req_received(req);
7773 0 : return NT_STATUS_OK;
7774 : }
7775 :
7776 0 : NTSTATUS dcerpc_clusapi_QueryValue_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_QueryValue *r)
7777 : {
7778 : NTSTATUS status;
7779 :
7780 0 : status = dcerpc_binding_handle_call(h,
7781 : NULL, &ndr_table_clusapi,
7782 : NDR_CLUSAPI_QUERYVALUE, mem_ctx, r);
7783 :
7784 0 : return status;
7785 : }
7786 :
7787 : struct dcerpc_clusapi_QueryValue_state {
7788 : struct clusapi_QueryValue orig;
7789 : struct clusapi_QueryValue tmp;
7790 : TALLOC_CTX *out_mem_ctx;
7791 : };
7792 :
7793 : static void dcerpc_clusapi_QueryValue_done(struct tevent_req *subreq);
7794 :
7795 0 : struct tevent_req *dcerpc_clusapi_QueryValue_send(TALLOC_CTX *mem_ctx,
7796 : struct tevent_context *ev,
7797 : struct dcerpc_binding_handle *h,
7798 : struct policy_handle _hKey /* [in] */,
7799 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7800 : enum winreg_Type *_lpValueType /* [out] [ref] */,
7801 : uint8_t *_lpData /* [out] [ref,size_is(cbData)] */,
7802 : uint32_t _cbData /* [in] */,
7803 : uint32_t *_lpcbRequired /* [out] [ref] */,
7804 : WERROR *_rpc_status /* [out] [ref] */)
7805 : {
7806 : struct tevent_req *req;
7807 : struct dcerpc_clusapi_QueryValue_state *state;
7808 : struct tevent_req *subreq;
7809 :
7810 0 : req = tevent_req_create(mem_ctx, &state,
7811 : struct dcerpc_clusapi_QueryValue_state);
7812 0 : if (req == NULL) {
7813 0 : return NULL;
7814 : }
7815 0 : state->out_mem_ctx = NULL;
7816 :
7817 : /* In parameters */
7818 0 : state->orig.in.hKey = _hKey;
7819 0 : state->orig.in.lpValueName = _lpValueName;
7820 0 : state->orig.in.cbData = _cbData;
7821 :
7822 : /* Out parameters */
7823 0 : state->orig.out.lpValueType = _lpValueType;
7824 0 : state->orig.out.lpData = _lpData;
7825 0 : state->orig.out.lpcbRequired = _lpcbRequired;
7826 0 : state->orig.out.rpc_status = _rpc_status;
7827 :
7828 : /* Result */
7829 0 : NDR_ZERO_STRUCT(state->orig.out.result);
7830 :
7831 0 : state->out_mem_ctx = talloc_named_const(state, 0,
7832 : "dcerpc_clusapi_QueryValue_out_memory");
7833 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7834 0 : return tevent_req_post(req, ev);
7835 : }
7836 :
7837 : /* make a temporary copy, that we pass to the dispatch function */
7838 0 : state->tmp = state->orig;
7839 :
7840 0 : subreq = dcerpc_clusapi_QueryValue_r_send(state, ev, h, &state->tmp);
7841 0 : if (tevent_req_nomem(subreq, req)) {
7842 0 : return tevent_req_post(req, ev);
7843 : }
7844 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryValue_done, req);
7845 0 : return req;
7846 : }
7847 :
7848 0 : static void dcerpc_clusapi_QueryValue_done(struct tevent_req *subreq)
7849 : {
7850 0 : struct tevent_req *req = tevent_req_callback_data(
7851 : subreq, struct tevent_req);
7852 0 : struct dcerpc_clusapi_QueryValue_state *state = tevent_req_data(
7853 : req, struct dcerpc_clusapi_QueryValue_state);
7854 : NTSTATUS status;
7855 : TALLOC_CTX *mem_ctx;
7856 :
7857 0 : if (state->out_mem_ctx) {
7858 0 : mem_ctx = state->out_mem_ctx;
7859 : } else {
7860 0 : mem_ctx = state;
7861 : }
7862 :
7863 0 : status = dcerpc_clusapi_QueryValue_r_recv(subreq, mem_ctx);
7864 0 : TALLOC_FREE(subreq);
7865 0 : if (tevent_req_nterror(req, status)) {
7866 0 : return;
7867 : }
7868 :
7869 : /* Copy out parameters */
7870 0 : *state->orig.out.lpValueType = *state->tmp.out.lpValueType;
7871 : {
7872 : size_t _copy_len_lpData;
7873 0 : _copy_len_lpData = state->tmp.in.cbData;
7874 0 : if (state->orig.out.lpData != state->tmp.out.lpData) {
7875 0 : memcpy(state->orig.out.lpData, state->tmp.out.lpData, _copy_len_lpData * sizeof(*state->orig.out.lpData));
7876 : }
7877 : }
7878 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
7879 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
7880 :
7881 : /* Copy result */
7882 0 : state->orig.out.result = state->tmp.out.result;
7883 :
7884 : /* Reset temporary structure */
7885 0 : NDR_ZERO_STRUCT(state->tmp);
7886 :
7887 0 : tevent_req_done(req);
7888 : }
7889 :
7890 0 : NTSTATUS dcerpc_clusapi_QueryValue_recv(struct tevent_req *req,
7891 : TALLOC_CTX *mem_ctx,
7892 : WERROR *result)
7893 : {
7894 0 : struct dcerpc_clusapi_QueryValue_state *state = tevent_req_data(
7895 : req, struct dcerpc_clusapi_QueryValue_state);
7896 : NTSTATUS status;
7897 :
7898 0 : if (tevent_req_is_nterror(req, &status)) {
7899 0 : tevent_req_received(req);
7900 0 : return status;
7901 : }
7902 :
7903 : /* Steal possible out parameters to the callers context */
7904 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
7905 :
7906 : /* Return result */
7907 0 : *result = state->orig.out.result;
7908 :
7909 0 : tevent_req_received(req);
7910 0 : return NT_STATUS_OK;
7911 : }
7912 :
7913 0 : NTSTATUS dcerpc_clusapi_QueryValue(struct dcerpc_binding_handle *h,
7914 : TALLOC_CTX *mem_ctx,
7915 : struct policy_handle _hKey /* [in] */,
7916 : const char *_lpValueName /* [in] [charset(UTF16),ref] */,
7917 : enum winreg_Type *_lpValueType /* [out] [ref] */,
7918 : uint8_t *_lpData /* [out] [ref,size_is(cbData)] */,
7919 : uint32_t _cbData /* [in] */,
7920 : uint32_t *_lpcbRequired /* [out] [ref] */,
7921 : WERROR *_rpc_status /* [out] [ref] */,
7922 : WERROR *result)
7923 : {
7924 : struct clusapi_QueryValue r;
7925 : NTSTATUS status;
7926 :
7927 : /* In parameters */
7928 0 : r.in.hKey = _hKey;
7929 0 : r.in.lpValueName = _lpValueName;
7930 0 : r.in.cbData = _cbData;
7931 :
7932 : /* Out parameters */
7933 0 : r.out.lpValueType = _lpValueType;
7934 0 : r.out.lpData = _lpData;
7935 0 : r.out.lpcbRequired = _lpcbRequired;
7936 0 : r.out.rpc_status = _rpc_status;
7937 :
7938 : /* Result */
7939 0 : NDR_ZERO_STRUCT(r.out.result);
7940 :
7941 0 : status = dcerpc_clusapi_QueryValue_r(h, mem_ctx, &r);
7942 0 : if (!NT_STATUS_IS_OK(status)) {
7943 0 : return status;
7944 : }
7945 :
7946 : /* Return variables */
7947 0 : *_lpValueType = *r.out.lpValueType;
7948 : {
7949 : size_t _copy_len_lpData;
7950 0 : _copy_len_lpData = r.in.cbData;
7951 0 : if (_lpData != r.out.lpData) {
7952 0 : memcpy(_lpData, r.out.lpData, _copy_len_lpData * sizeof(*_lpData));
7953 : }
7954 : }
7955 0 : *_lpcbRequired = *r.out.lpcbRequired;
7956 0 : *_rpc_status = *r.out.rpc_status;
7957 :
7958 : /* Return result */
7959 0 : *result = r.out.result;
7960 :
7961 0 : return NT_STATUS_OK;
7962 : }
7963 :
7964 : struct dcerpc_clusapi_DeleteKey_r_state {
7965 : TALLOC_CTX *out_mem_ctx;
7966 : };
7967 :
7968 : static void dcerpc_clusapi_DeleteKey_r_done(struct tevent_req *subreq);
7969 :
7970 0 : struct tevent_req *dcerpc_clusapi_DeleteKey_r_send(TALLOC_CTX *mem_ctx,
7971 : struct tevent_context *ev,
7972 : struct dcerpc_binding_handle *h,
7973 : struct clusapi_DeleteKey *r)
7974 : {
7975 : struct tevent_req *req;
7976 : struct dcerpc_clusapi_DeleteKey_r_state *state;
7977 : struct tevent_req *subreq;
7978 :
7979 0 : req = tevent_req_create(mem_ctx, &state,
7980 : struct dcerpc_clusapi_DeleteKey_r_state);
7981 0 : if (req == NULL) {
7982 0 : return NULL;
7983 : }
7984 :
7985 0 : state->out_mem_ctx = talloc_new(state);
7986 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
7987 0 : return tevent_req_post(req, ev);
7988 : }
7989 :
7990 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
7991 : NULL, &ndr_table_clusapi,
7992 0 : NDR_CLUSAPI_DELETEKEY, state->out_mem_ctx, r);
7993 0 : if (tevent_req_nomem(subreq, req)) {
7994 0 : return tevent_req_post(req, ev);
7995 : }
7996 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteKey_r_done, req);
7997 :
7998 0 : return req;
7999 : }
8000 :
8001 0 : static void dcerpc_clusapi_DeleteKey_r_done(struct tevent_req *subreq)
8002 : {
8003 0 : struct tevent_req *req =
8004 0 : tevent_req_callback_data(subreq,
8005 : struct tevent_req);
8006 : NTSTATUS status;
8007 :
8008 0 : status = dcerpc_binding_handle_call_recv(subreq);
8009 0 : TALLOC_FREE(subreq);
8010 0 : if (tevent_req_nterror(req, status)) {
8011 0 : return;
8012 : }
8013 :
8014 0 : tevent_req_done(req);
8015 : }
8016 :
8017 0 : NTSTATUS dcerpc_clusapi_DeleteKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8018 : {
8019 0 : struct dcerpc_clusapi_DeleteKey_r_state *state =
8020 0 : tevent_req_data(req,
8021 : struct dcerpc_clusapi_DeleteKey_r_state);
8022 : NTSTATUS status;
8023 :
8024 0 : if (tevent_req_is_nterror(req, &status)) {
8025 0 : tevent_req_received(req);
8026 0 : return status;
8027 : }
8028 :
8029 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8030 :
8031 0 : tevent_req_received(req);
8032 0 : return NT_STATUS_OK;
8033 : }
8034 :
8035 0 : NTSTATUS dcerpc_clusapi_DeleteKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteKey *r)
8036 : {
8037 : NTSTATUS status;
8038 :
8039 0 : status = dcerpc_binding_handle_call(h,
8040 : NULL, &ndr_table_clusapi,
8041 : NDR_CLUSAPI_DELETEKEY, mem_ctx, r);
8042 :
8043 0 : return status;
8044 : }
8045 :
8046 : struct dcerpc_clusapi_DeleteKey_state {
8047 : struct clusapi_DeleteKey orig;
8048 : struct clusapi_DeleteKey tmp;
8049 : TALLOC_CTX *out_mem_ctx;
8050 : };
8051 :
8052 : static void dcerpc_clusapi_DeleteKey_done(struct tevent_req *subreq);
8053 :
8054 0 : struct tevent_req *dcerpc_clusapi_DeleteKey_send(TALLOC_CTX *mem_ctx,
8055 : struct tevent_context *ev,
8056 : struct dcerpc_binding_handle *h,
8057 : struct policy_handle _hKey /* [in] */,
8058 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
8059 : WERROR *_rpc_status /* [out] [ref] */)
8060 : {
8061 : struct tevent_req *req;
8062 : struct dcerpc_clusapi_DeleteKey_state *state;
8063 : struct tevent_req *subreq;
8064 :
8065 0 : req = tevent_req_create(mem_ctx, &state,
8066 : struct dcerpc_clusapi_DeleteKey_state);
8067 0 : if (req == NULL) {
8068 0 : return NULL;
8069 : }
8070 0 : state->out_mem_ctx = NULL;
8071 :
8072 : /* In parameters */
8073 0 : state->orig.in.hKey = _hKey;
8074 0 : state->orig.in.lpSubKey = _lpSubKey;
8075 :
8076 : /* Out parameters */
8077 0 : state->orig.out.rpc_status = _rpc_status;
8078 :
8079 : /* Result */
8080 0 : NDR_ZERO_STRUCT(state->orig.out.result);
8081 :
8082 0 : state->out_mem_ctx = talloc_named_const(state, 0,
8083 : "dcerpc_clusapi_DeleteKey_out_memory");
8084 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8085 0 : return tevent_req_post(req, ev);
8086 : }
8087 :
8088 : /* make a temporary copy, that we pass to the dispatch function */
8089 0 : state->tmp = state->orig;
8090 :
8091 0 : subreq = dcerpc_clusapi_DeleteKey_r_send(state, ev, h, &state->tmp);
8092 0 : if (tevent_req_nomem(subreq, req)) {
8093 0 : return tevent_req_post(req, ev);
8094 : }
8095 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteKey_done, req);
8096 0 : return req;
8097 : }
8098 :
8099 0 : static void dcerpc_clusapi_DeleteKey_done(struct tevent_req *subreq)
8100 : {
8101 0 : struct tevent_req *req = tevent_req_callback_data(
8102 : subreq, struct tevent_req);
8103 0 : struct dcerpc_clusapi_DeleteKey_state *state = tevent_req_data(
8104 : req, struct dcerpc_clusapi_DeleteKey_state);
8105 : NTSTATUS status;
8106 : TALLOC_CTX *mem_ctx;
8107 :
8108 0 : if (state->out_mem_ctx) {
8109 0 : mem_ctx = state->out_mem_ctx;
8110 : } else {
8111 0 : mem_ctx = state;
8112 : }
8113 :
8114 0 : status = dcerpc_clusapi_DeleteKey_r_recv(subreq, mem_ctx);
8115 0 : TALLOC_FREE(subreq);
8116 0 : if (tevent_req_nterror(req, status)) {
8117 0 : return;
8118 : }
8119 :
8120 : /* Copy out parameters */
8121 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
8122 :
8123 : /* Copy result */
8124 0 : state->orig.out.result = state->tmp.out.result;
8125 :
8126 : /* Reset temporary structure */
8127 0 : NDR_ZERO_STRUCT(state->tmp);
8128 :
8129 0 : tevent_req_done(req);
8130 : }
8131 :
8132 0 : NTSTATUS dcerpc_clusapi_DeleteKey_recv(struct tevent_req *req,
8133 : TALLOC_CTX *mem_ctx,
8134 : WERROR *result)
8135 : {
8136 0 : struct dcerpc_clusapi_DeleteKey_state *state = tevent_req_data(
8137 : req, struct dcerpc_clusapi_DeleteKey_state);
8138 : NTSTATUS status;
8139 :
8140 0 : if (tevent_req_is_nterror(req, &status)) {
8141 0 : tevent_req_received(req);
8142 0 : return status;
8143 : }
8144 :
8145 : /* Steal possible out parameters to the callers context */
8146 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8147 :
8148 : /* Return result */
8149 0 : *result = state->orig.out.result;
8150 :
8151 0 : tevent_req_received(req);
8152 0 : return NT_STATUS_OK;
8153 : }
8154 :
8155 0 : NTSTATUS dcerpc_clusapi_DeleteKey(struct dcerpc_binding_handle *h,
8156 : TALLOC_CTX *mem_ctx,
8157 : struct policy_handle _hKey /* [in] */,
8158 : const char *_lpSubKey /* [in] [charset(UTF16),ref] */,
8159 : WERROR *_rpc_status /* [out] [ref] */,
8160 : WERROR *result)
8161 : {
8162 : struct clusapi_DeleteKey r;
8163 : NTSTATUS status;
8164 :
8165 : /* In parameters */
8166 0 : r.in.hKey = _hKey;
8167 0 : r.in.lpSubKey = _lpSubKey;
8168 :
8169 : /* Out parameters */
8170 0 : r.out.rpc_status = _rpc_status;
8171 :
8172 : /* Result */
8173 0 : NDR_ZERO_STRUCT(r.out.result);
8174 :
8175 0 : status = dcerpc_clusapi_DeleteKey_r(h, mem_ctx, &r);
8176 0 : if (!NT_STATUS_IS_OK(status)) {
8177 0 : return status;
8178 : }
8179 :
8180 : /* Return variables */
8181 0 : *_rpc_status = *r.out.rpc_status;
8182 :
8183 : /* Return result */
8184 0 : *result = r.out.result;
8185 :
8186 0 : return NT_STATUS_OK;
8187 : }
8188 :
8189 : struct dcerpc_clusapi_EnumValue_r_state {
8190 : TALLOC_CTX *out_mem_ctx;
8191 : };
8192 :
8193 : static void dcerpc_clusapi_EnumValue_r_done(struct tevent_req *subreq);
8194 :
8195 0 : struct tevent_req *dcerpc_clusapi_EnumValue_r_send(TALLOC_CTX *mem_ctx,
8196 : struct tevent_context *ev,
8197 : struct dcerpc_binding_handle *h,
8198 : struct clusapi_EnumValue *r)
8199 : {
8200 : struct tevent_req *req;
8201 : struct dcerpc_clusapi_EnumValue_r_state *state;
8202 : struct tevent_req *subreq;
8203 :
8204 0 : req = tevent_req_create(mem_ctx, &state,
8205 : struct dcerpc_clusapi_EnumValue_r_state);
8206 0 : if (req == NULL) {
8207 0 : return NULL;
8208 : }
8209 :
8210 0 : state->out_mem_ctx = talloc_new(state);
8211 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8212 0 : return tevent_req_post(req, ev);
8213 : }
8214 :
8215 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
8216 : NULL, &ndr_table_clusapi,
8217 0 : NDR_CLUSAPI_ENUMVALUE, state->out_mem_ctx, r);
8218 0 : if (tevent_req_nomem(subreq, req)) {
8219 0 : return tevent_req_post(req, ev);
8220 : }
8221 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EnumValue_r_done, req);
8222 :
8223 0 : return req;
8224 : }
8225 :
8226 0 : static void dcerpc_clusapi_EnumValue_r_done(struct tevent_req *subreq)
8227 : {
8228 0 : struct tevent_req *req =
8229 0 : tevent_req_callback_data(subreq,
8230 : struct tevent_req);
8231 : NTSTATUS status;
8232 :
8233 0 : status = dcerpc_binding_handle_call_recv(subreq);
8234 0 : TALLOC_FREE(subreq);
8235 0 : if (tevent_req_nterror(req, status)) {
8236 0 : return;
8237 : }
8238 :
8239 0 : tevent_req_done(req);
8240 : }
8241 :
8242 0 : NTSTATUS dcerpc_clusapi_EnumValue_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8243 : {
8244 0 : struct dcerpc_clusapi_EnumValue_r_state *state =
8245 0 : tevent_req_data(req,
8246 : struct dcerpc_clusapi_EnumValue_r_state);
8247 : NTSTATUS status;
8248 :
8249 0 : if (tevent_req_is_nterror(req, &status)) {
8250 0 : tevent_req_received(req);
8251 0 : return status;
8252 : }
8253 :
8254 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8255 :
8256 0 : tevent_req_received(req);
8257 0 : return NT_STATUS_OK;
8258 : }
8259 :
8260 0 : NTSTATUS dcerpc_clusapi_EnumValue_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_EnumValue *r)
8261 : {
8262 : NTSTATUS status;
8263 :
8264 0 : status = dcerpc_binding_handle_call(h,
8265 : NULL, &ndr_table_clusapi,
8266 : NDR_CLUSAPI_ENUMVALUE, mem_ctx, r);
8267 :
8268 0 : return status;
8269 : }
8270 :
8271 : struct dcerpc_clusapi_EnumValue_state {
8272 : struct clusapi_EnumValue orig;
8273 : struct clusapi_EnumValue tmp;
8274 : TALLOC_CTX *out_mem_ctx;
8275 : };
8276 :
8277 : static void dcerpc_clusapi_EnumValue_done(struct tevent_req *subreq);
8278 :
8279 0 : struct tevent_req *dcerpc_clusapi_EnumValue_send(TALLOC_CTX *mem_ctx,
8280 : struct tevent_context *ev,
8281 : struct dcerpc_binding_handle *h,
8282 : struct policy_handle _hKey /* [in] */,
8283 : uint32_t _dwIndex /* [in] */,
8284 : const char **_lpValueName /* [out] [charset(UTF16),ref] */,
8285 : enum winreg_Type *_lpType /* [out] [ref] */,
8286 : uint8_t *_lpData /* [out] [ref,size_is(*lpcbData)] */,
8287 : uint32_t *_lpcbData /* [in,out] [ref] */,
8288 : uint32_t *_TotalSize /* [out] [ref] */,
8289 : WERROR *_rpc_status /* [out] [ref] */)
8290 : {
8291 : struct tevent_req *req;
8292 : struct dcerpc_clusapi_EnumValue_state *state;
8293 : struct tevent_req *subreq;
8294 :
8295 0 : req = tevent_req_create(mem_ctx, &state,
8296 : struct dcerpc_clusapi_EnumValue_state);
8297 0 : if (req == NULL) {
8298 0 : return NULL;
8299 : }
8300 0 : state->out_mem_ctx = NULL;
8301 :
8302 : /* In parameters */
8303 0 : state->orig.in.hKey = _hKey;
8304 0 : state->orig.in.dwIndex = _dwIndex;
8305 0 : state->orig.in.lpcbData = _lpcbData;
8306 :
8307 : /* Out parameters */
8308 0 : state->orig.out.lpValueName = _lpValueName;
8309 0 : state->orig.out.lpType = _lpType;
8310 0 : state->orig.out.lpData = _lpData;
8311 0 : state->orig.out.lpcbData = _lpcbData;
8312 0 : state->orig.out.TotalSize = _TotalSize;
8313 0 : state->orig.out.rpc_status = _rpc_status;
8314 :
8315 : /* Result */
8316 0 : NDR_ZERO_STRUCT(state->orig.out.result);
8317 :
8318 0 : state->out_mem_ctx = talloc_named_const(state, 0,
8319 : "dcerpc_clusapi_EnumValue_out_memory");
8320 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8321 0 : return tevent_req_post(req, ev);
8322 : }
8323 :
8324 : /* make a temporary copy, that we pass to the dispatch function */
8325 0 : state->tmp = state->orig;
8326 :
8327 0 : subreq = dcerpc_clusapi_EnumValue_r_send(state, ev, h, &state->tmp);
8328 0 : if (tevent_req_nomem(subreq, req)) {
8329 0 : return tevent_req_post(req, ev);
8330 : }
8331 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EnumValue_done, req);
8332 0 : return req;
8333 : }
8334 :
8335 0 : static void dcerpc_clusapi_EnumValue_done(struct tevent_req *subreq)
8336 : {
8337 0 : struct tevent_req *req = tevent_req_callback_data(
8338 : subreq, struct tevent_req);
8339 0 : struct dcerpc_clusapi_EnumValue_state *state = tevent_req_data(
8340 : req, struct dcerpc_clusapi_EnumValue_state);
8341 : NTSTATUS status;
8342 : TALLOC_CTX *mem_ctx;
8343 :
8344 0 : if (state->out_mem_ctx) {
8345 0 : mem_ctx = state->out_mem_ctx;
8346 : } else {
8347 0 : mem_ctx = state;
8348 : }
8349 :
8350 0 : status = dcerpc_clusapi_EnumValue_r_recv(subreq, mem_ctx);
8351 0 : TALLOC_FREE(subreq);
8352 0 : if (tevent_req_nterror(req, status)) {
8353 0 : return;
8354 : }
8355 :
8356 : /* Copy out parameters */
8357 0 : *state->orig.out.lpValueName = *state->tmp.out.lpValueName;
8358 0 : *state->orig.out.lpType = *state->tmp.out.lpType;
8359 : {
8360 : size_t _copy_len_lpData;
8361 0 : if ((*state->tmp.out.lpcbData) > (*state->tmp.in.lpcbData)) {
8362 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
8363 0 : return;
8364 : }
8365 0 : _copy_len_lpData = *state->tmp.out.lpcbData;
8366 0 : if (state->orig.out.lpData != state->tmp.out.lpData) {
8367 0 : memcpy(state->orig.out.lpData, state->tmp.out.lpData, _copy_len_lpData * sizeof(*state->orig.out.lpData));
8368 : }
8369 : }
8370 0 : *state->orig.out.lpcbData = *state->tmp.out.lpcbData;
8371 0 : *state->orig.out.TotalSize = *state->tmp.out.TotalSize;
8372 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
8373 :
8374 : /* Copy result */
8375 0 : state->orig.out.result = state->tmp.out.result;
8376 :
8377 : /* Reset temporary structure */
8378 0 : NDR_ZERO_STRUCT(state->tmp);
8379 :
8380 0 : tevent_req_done(req);
8381 : }
8382 :
8383 0 : NTSTATUS dcerpc_clusapi_EnumValue_recv(struct tevent_req *req,
8384 : TALLOC_CTX *mem_ctx,
8385 : WERROR *result)
8386 : {
8387 0 : struct dcerpc_clusapi_EnumValue_state *state = tevent_req_data(
8388 : req, struct dcerpc_clusapi_EnumValue_state);
8389 : NTSTATUS status;
8390 :
8391 0 : if (tevent_req_is_nterror(req, &status)) {
8392 0 : tevent_req_received(req);
8393 0 : return status;
8394 : }
8395 :
8396 : /* Steal possible out parameters to the callers context */
8397 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8398 :
8399 : /* Return result */
8400 0 : *result = state->orig.out.result;
8401 :
8402 0 : tevent_req_received(req);
8403 0 : return NT_STATUS_OK;
8404 : }
8405 :
8406 0 : NTSTATUS dcerpc_clusapi_EnumValue(struct dcerpc_binding_handle *h,
8407 : TALLOC_CTX *mem_ctx,
8408 : struct policy_handle _hKey /* [in] */,
8409 : uint32_t _dwIndex /* [in] */,
8410 : const char **_lpValueName /* [out] [charset(UTF16),ref] */,
8411 : enum winreg_Type *_lpType /* [out] [ref] */,
8412 : uint8_t *_lpData /* [out] [ref,size_is(*lpcbData)] */,
8413 : uint32_t *_lpcbData /* [in,out] [ref] */,
8414 : uint32_t *_TotalSize /* [out] [ref] */,
8415 : WERROR *_rpc_status /* [out] [ref] */,
8416 : WERROR *result)
8417 : {
8418 : struct clusapi_EnumValue r;
8419 : NTSTATUS status;
8420 :
8421 : /* In parameters */
8422 0 : r.in.hKey = _hKey;
8423 0 : r.in.dwIndex = _dwIndex;
8424 0 : r.in.lpcbData = _lpcbData;
8425 :
8426 : /* Out parameters */
8427 0 : r.out.lpValueName = _lpValueName;
8428 0 : r.out.lpType = _lpType;
8429 0 : r.out.lpData = _lpData;
8430 0 : r.out.lpcbData = _lpcbData;
8431 0 : r.out.TotalSize = _TotalSize;
8432 0 : r.out.rpc_status = _rpc_status;
8433 :
8434 : /* Result */
8435 0 : NDR_ZERO_STRUCT(r.out.result);
8436 :
8437 0 : status = dcerpc_clusapi_EnumValue_r(h, mem_ctx, &r);
8438 0 : if (!NT_STATUS_IS_OK(status)) {
8439 0 : return status;
8440 : }
8441 :
8442 : /* Return variables */
8443 0 : *_lpValueName = *r.out.lpValueName;
8444 0 : *_lpType = *r.out.lpType;
8445 : {
8446 : size_t _copy_len_lpData;
8447 0 : if ((*r.out.lpcbData) > (*r.in.lpcbData)) {
8448 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
8449 : }
8450 0 : _copy_len_lpData = *r.out.lpcbData;
8451 0 : if (_lpData != r.out.lpData) {
8452 0 : memcpy(_lpData, r.out.lpData, _copy_len_lpData * sizeof(*_lpData));
8453 : }
8454 : }
8455 0 : *_lpcbData = *r.out.lpcbData;
8456 0 : *_TotalSize = *r.out.TotalSize;
8457 0 : *_rpc_status = *r.out.rpc_status;
8458 :
8459 : /* Return result */
8460 0 : *result = r.out.result;
8461 :
8462 0 : return NT_STATUS_OK;
8463 : }
8464 :
8465 : struct dcerpc_clusapi_CloseKey_r_state {
8466 : TALLOC_CTX *out_mem_ctx;
8467 : };
8468 :
8469 : static void dcerpc_clusapi_CloseKey_r_done(struct tevent_req *subreq);
8470 :
8471 0 : struct tevent_req *dcerpc_clusapi_CloseKey_r_send(TALLOC_CTX *mem_ctx,
8472 : struct tevent_context *ev,
8473 : struct dcerpc_binding_handle *h,
8474 : struct clusapi_CloseKey *r)
8475 : {
8476 : struct tevent_req *req;
8477 : struct dcerpc_clusapi_CloseKey_r_state *state;
8478 : struct tevent_req *subreq;
8479 :
8480 0 : req = tevent_req_create(mem_ctx, &state,
8481 : struct dcerpc_clusapi_CloseKey_r_state);
8482 0 : if (req == NULL) {
8483 0 : return NULL;
8484 : }
8485 :
8486 0 : state->out_mem_ctx = talloc_new(state);
8487 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8488 0 : return tevent_req_post(req, ev);
8489 : }
8490 :
8491 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
8492 : NULL, &ndr_table_clusapi,
8493 0 : NDR_CLUSAPI_CLOSEKEY, state->out_mem_ctx, r);
8494 0 : if (tevent_req_nomem(subreq, req)) {
8495 0 : return tevent_req_post(req, ev);
8496 : }
8497 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseKey_r_done, req);
8498 :
8499 0 : return req;
8500 : }
8501 :
8502 0 : static void dcerpc_clusapi_CloseKey_r_done(struct tevent_req *subreq)
8503 : {
8504 0 : struct tevent_req *req =
8505 0 : tevent_req_callback_data(subreq,
8506 : struct tevent_req);
8507 : NTSTATUS status;
8508 :
8509 0 : status = dcerpc_binding_handle_call_recv(subreq);
8510 0 : TALLOC_FREE(subreq);
8511 0 : if (tevent_req_nterror(req, status)) {
8512 0 : return;
8513 : }
8514 :
8515 0 : tevent_req_done(req);
8516 : }
8517 :
8518 0 : NTSTATUS dcerpc_clusapi_CloseKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8519 : {
8520 0 : struct dcerpc_clusapi_CloseKey_r_state *state =
8521 0 : tevent_req_data(req,
8522 : struct dcerpc_clusapi_CloseKey_r_state);
8523 : NTSTATUS status;
8524 :
8525 0 : if (tevent_req_is_nterror(req, &status)) {
8526 0 : tevent_req_received(req);
8527 0 : return status;
8528 : }
8529 :
8530 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8531 :
8532 0 : tevent_req_received(req);
8533 0 : return NT_STATUS_OK;
8534 : }
8535 :
8536 0 : NTSTATUS dcerpc_clusapi_CloseKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseKey *r)
8537 : {
8538 : NTSTATUS status;
8539 :
8540 0 : status = dcerpc_binding_handle_call(h,
8541 : NULL, &ndr_table_clusapi,
8542 : NDR_CLUSAPI_CLOSEKEY, mem_ctx, r);
8543 :
8544 0 : return status;
8545 : }
8546 :
8547 : struct dcerpc_clusapi_CloseKey_state {
8548 : struct clusapi_CloseKey orig;
8549 : struct clusapi_CloseKey tmp;
8550 : TALLOC_CTX *out_mem_ctx;
8551 : };
8552 :
8553 : static void dcerpc_clusapi_CloseKey_done(struct tevent_req *subreq);
8554 :
8555 0 : struct tevent_req *dcerpc_clusapi_CloseKey_send(TALLOC_CTX *mem_ctx,
8556 : struct tevent_context *ev,
8557 : struct dcerpc_binding_handle *h,
8558 : struct policy_handle *_pKey /* [in,out] [ref] */)
8559 : {
8560 : struct tevent_req *req;
8561 : struct dcerpc_clusapi_CloseKey_state *state;
8562 : struct tevent_req *subreq;
8563 :
8564 0 : req = tevent_req_create(mem_ctx, &state,
8565 : struct dcerpc_clusapi_CloseKey_state);
8566 0 : if (req == NULL) {
8567 0 : return NULL;
8568 : }
8569 0 : state->out_mem_ctx = NULL;
8570 :
8571 : /* In parameters */
8572 0 : state->orig.in.pKey = _pKey;
8573 :
8574 : /* Out parameters */
8575 0 : state->orig.out.pKey = _pKey;
8576 :
8577 : /* Result */
8578 0 : NDR_ZERO_STRUCT(state->orig.out.result);
8579 :
8580 0 : state->out_mem_ctx = talloc_named_const(state, 0,
8581 : "dcerpc_clusapi_CloseKey_out_memory");
8582 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8583 0 : return tevent_req_post(req, ev);
8584 : }
8585 :
8586 : /* make a temporary copy, that we pass to the dispatch function */
8587 0 : state->tmp = state->orig;
8588 :
8589 0 : subreq = dcerpc_clusapi_CloseKey_r_send(state, ev, h, &state->tmp);
8590 0 : if (tevent_req_nomem(subreq, req)) {
8591 0 : return tevent_req_post(req, ev);
8592 : }
8593 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseKey_done, req);
8594 0 : return req;
8595 : }
8596 :
8597 0 : static void dcerpc_clusapi_CloseKey_done(struct tevent_req *subreq)
8598 : {
8599 0 : struct tevent_req *req = tevent_req_callback_data(
8600 : subreq, struct tevent_req);
8601 0 : struct dcerpc_clusapi_CloseKey_state *state = tevent_req_data(
8602 : req, struct dcerpc_clusapi_CloseKey_state);
8603 : NTSTATUS status;
8604 : TALLOC_CTX *mem_ctx;
8605 :
8606 0 : if (state->out_mem_ctx) {
8607 0 : mem_ctx = state->out_mem_ctx;
8608 : } else {
8609 0 : mem_ctx = state;
8610 : }
8611 :
8612 0 : status = dcerpc_clusapi_CloseKey_r_recv(subreq, mem_ctx);
8613 0 : TALLOC_FREE(subreq);
8614 0 : if (tevent_req_nterror(req, status)) {
8615 0 : return;
8616 : }
8617 :
8618 : /* Copy out parameters */
8619 0 : *state->orig.out.pKey = *state->tmp.out.pKey;
8620 :
8621 : /* Copy result */
8622 0 : state->orig.out.result = state->tmp.out.result;
8623 :
8624 : /* Reset temporary structure */
8625 0 : NDR_ZERO_STRUCT(state->tmp);
8626 :
8627 0 : tevent_req_done(req);
8628 : }
8629 :
8630 0 : NTSTATUS dcerpc_clusapi_CloseKey_recv(struct tevent_req *req,
8631 : TALLOC_CTX *mem_ctx,
8632 : WERROR *result)
8633 : {
8634 0 : struct dcerpc_clusapi_CloseKey_state *state = tevent_req_data(
8635 : req, struct dcerpc_clusapi_CloseKey_state);
8636 : NTSTATUS status;
8637 :
8638 0 : if (tevent_req_is_nterror(req, &status)) {
8639 0 : tevent_req_received(req);
8640 0 : return status;
8641 : }
8642 :
8643 : /* Steal possible out parameters to the callers context */
8644 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8645 :
8646 : /* Return result */
8647 0 : *result = state->orig.out.result;
8648 :
8649 0 : tevent_req_received(req);
8650 0 : return NT_STATUS_OK;
8651 : }
8652 :
8653 0 : NTSTATUS dcerpc_clusapi_CloseKey(struct dcerpc_binding_handle *h,
8654 : TALLOC_CTX *mem_ctx,
8655 : struct policy_handle *_pKey /* [in,out] [ref] */,
8656 : WERROR *result)
8657 : {
8658 : struct clusapi_CloseKey r;
8659 : NTSTATUS status;
8660 :
8661 : /* In parameters */
8662 0 : r.in.pKey = _pKey;
8663 :
8664 : /* Out parameters */
8665 0 : r.out.pKey = _pKey;
8666 :
8667 : /* Result */
8668 0 : NDR_ZERO_STRUCT(r.out.result);
8669 :
8670 0 : status = dcerpc_clusapi_CloseKey_r(h, mem_ctx, &r);
8671 0 : if (!NT_STATUS_IS_OK(status)) {
8672 0 : return status;
8673 : }
8674 :
8675 : /* Return variables */
8676 0 : *_pKey = *r.out.pKey;
8677 :
8678 : /* Return result */
8679 0 : *result = r.out.result;
8680 :
8681 0 : return NT_STATUS_OK;
8682 : }
8683 :
8684 : struct dcerpc_clusapi_QueryInfoKey_r_state {
8685 : TALLOC_CTX *out_mem_ctx;
8686 : };
8687 :
8688 : static void dcerpc_clusapi_QueryInfoKey_r_done(struct tevent_req *subreq);
8689 :
8690 0 : struct tevent_req *dcerpc_clusapi_QueryInfoKey_r_send(TALLOC_CTX *mem_ctx,
8691 : struct tevent_context *ev,
8692 : struct dcerpc_binding_handle *h,
8693 : struct clusapi_QueryInfoKey *r)
8694 : {
8695 : struct tevent_req *req;
8696 : struct dcerpc_clusapi_QueryInfoKey_r_state *state;
8697 : struct tevent_req *subreq;
8698 :
8699 0 : req = tevent_req_create(mem_ctx, &state,
8700 : struct dcerpc_clusapi_QueryInfoKey_r_state);
8701 0 : if (req == NULL) {
8702 0 : return NULL;
8703 : }
8704 :
8705 0 : state->out_mem_ctx = talloc_new(state);
8706 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8707 0 : return tevent_req_post(req, ev);
8708 : }
8709 :
8710 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
8711 : NULL, &ndr_table_clusapi,
8712 0 : NDR_CLUSAPI_QUERYINFOKEY, state->out_mem_ctx, r);
8713 0 : if (tevent_req_nomem(subreq, req)) {
8714 0 : return tevent_req_post(req, ev);
8715 : }
8716 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryInfoKey_r_done, req);
8717 :
8718 0 : return req;
8719 : }
8720 :
8721 0 : static void dcerpc_clusapi_QueryInfoKey_r_done(struct tevent_req *subreq)
8722 : {
8723 0 : struct tevent_req *req =
8724 0 : tevent_req_callback_data(subreq,
8725 : struct tevent_req);
8726 : NTSTATUS status;
8727 :
8728 0 : status = dcerpc_binding_handle_call_recv(subreq);
8729 0 : TALLOC_FREE(subreq);
8730 0 : if (tevent_req_nterror(req, status)) {
8731 0 : return;
8732 : }
8733 :
8734 0 : tevent_req_done(req);
8735 : }
8736 :
8737 0 : NTSTATUS dcerpc_clusapi_QueryInfoKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8738 : {
8739 0 : struct dcerpc_clusapi_QueryInfoKey_r_state *state =
8740 0 : tevent_req_data(req,
8741 : struct dcerpc_clusapi_QueryInfoKey_r_state);
8742 : NTSTATUS status;
8743 :
8744 0 : if (tevent_req_is_nterror(req, &status)) {
8745 0 : tevent_req_received(req);
8746 0 : return status;
8747 : }
8748 :
8749 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8750 :
8751 0 : tevent_req_received(req);
8752 0 : return NT_STATUS_OK;
8753 : }
8754 :
8755 0 : NTSTATUS dcerpc_clusapi_QueryInfoKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_QueryInfoKey *r)
8756 : {
8757 : NTSTATUS status;
8758 :
8759 0 : status = dcerpc_binding_handle_call(h,
8760 : NULL, &ndr_table_clusapi,
8761 : NDR_CLUSAPI_QUERYINFOKEY, mem_ctx, r);
8762 :
8763 0 : return status;
8764 : }
8765 :
8766 : struct dcerpc_clusapi_QueryInfoKey_state {
8767 : struct clusapi_QueryInfoKey orig;
8768 : struct clusapi_QueryInfoKey tmp;
8769 : TALLOC_CTX *out_mem_ctx;
8770 : };
8771 :
8772 : static void dcerpc_clusapi_QueryInfoKey_done(struct tevent_req *subreq);
8773 :
8774 0 : struct tevent_req *dcerpc_clusapi_QueryInfoKey_send(TALLOC_CTX *mem_ctx,
8775 : struct tevent_context *ev,
8776 : struct dcerpc_binding_handle *h,
8777 : struct policy_handle _hKey /* [in] */,
8778 : uint32_t *_lpcSubKeys /* [out] [ref] */,
8779 : uint32_t *_lpcbMaxSubKeyLen /* [out] [ref] */,
8780 : uint32_t *_lpcValues /* [out] [ref] */,
8781 : uint32_t *_lpcbMaxValueNameLen /* [out] [ref] */,
8782 : uint32_t *_lpcbMaxValueLen /* [out] [ref] */,
8783 : uint32_t *_lpcbSecurityDescriptor /* [out] [ref] */,
8784 : NTTIME *_lpftLastWriteTime /* [out] [ref] */,
8785 : WERROR *_rpc_status /* [out] [ref] */)
8786 : {
8787 : struct tevent_req *req;
8788 : struct dcerpc_clusapi_QueryInfoKey_state *state;
8789 : struct tevent_req *subreq;
8790 :
8791 0 : req = tevent_req_create(mem_ctx, &state,
8792 : struct dcerpc_clusapi_QueryInfoKey_state);
8793 0 : if (req == NULL) {
8794 0 : return NULL;
8795 : }
8796 0 : state->out_mem_ctx = NULL;
8797 :
8798 : /* In parameters */
8799 0 : state->orig.in.hKey = _hKey;
8800 :
8801 : /* Out parameters */
8802 0 : state->orig.out.lpcSubKeys = _lpcSubKeys;
8803 0 : state->orig.out.lpcbMaxSubKeyLen = _lpcbMaxSubKeyLen;
8804 0 : state->orig.out.lpcValues = _lpcValues;
8805 0 : state->orig.out.lpcbMaxValueNameLen = _lpcbMaxValueNameLen;
8806 0 : state->orig.out.lpcbMaxValueLen = _lpcbMaxValueLen;
8807 0 : state->orig.out.lpcbSecurityDescriptor = _lpcbSecurityDescriptor;
8808 0 : state->orig.out.lpftLastWriteTime = _lpftLastWriteTime;
8809 0 : state->orig.out.rpc_status = _rpc_status;
8810 :
8811 : /* Result */
8812 0 : NDR_ZERO_STRUCT(state->orig.out.result);
8813 :
8814 0 : state->out_mem_ctx = talloc_named_const(state, 0,
8815 : "dcerpc_clusapi_QueryInfoKey_out_memory");
8816 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8817 0 : return tevent_req_post(req, ev);
8818 : }
8819 :
8820 : /* make a temporary copy, that we pass to the dispatch function */
8821 0 : state->tmp = state->orig;
8822 :
8823 0 : subreq = dcerpc_clusapi_QueryInfoKey_r_send(state, ev, h, &state->tmp);
8824 0 : if (tevent_req_nomem(subreq, req)) {
8825 0 : return tevent_req_post(req, ev);
8826 : }
8827 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryInfoKey_done, req);
8828 0 : return req;
8829 : }
8830 :
8831 0 : static void dcerpc_clusapi_QueryInfoKey_done(struct tevent_req *subreq)
8832 : {
8833 0 : struct tevent_req *req = tevent_req_callback_data(
8834 : subreq, struct tevent_req);
8835 0 : struct dcerpc_clusapi_QueryInfoKey_state *state = tevent_req_data(
8836 : req, struct dcerpc_clusapi_QueryInfoKey_state);
8837 : NTSTATUS status;
8838 : TALLOC_CTX *mem_ctx;
8839 :
8840 0 : if (state->out_mem_ctx) {
8841 0 : mem_ctx = state->out_mem_ctx;
8842 : } else {
8843 0 : mem_ctx = state;
8844 : }
8845 :
8846 0 : status = dcerpc_clusapi_QueryInfoKey_r_recv(subreq, mem_ctx);
8847 0 : TALLOC_FREE(subreq);
8848 0 : if (tevent_req_nterror(req, status)) {
8849 0 : return;
8850 : }
8851 :
8852 : /* Copy out parameters */
8853 0 : *state->orig.out.lpcSubKeys = *state->tmp.out.lpcSubKeys;
8854 0 : *state->orig.out.lpcbMaxSubKeyLen = *state->tmp.out.lpcbMaxSubKeyLen;
8855 0 : *state->orig.out.lpcValues = *state->tmp.out.lpcValues;
8856 0 : *state->orig.out.lpcbMaxValueNameLen = *state->tmp.out.lpcbMaxValueNameLen;
8857 0 : *state->orig.out.lpcbMaxValueLen = *state->tmp.out.lpcbMaxValueLen;
8858 0 : *state->orig.out.lpcbSecurityDescriptor = *state->tmp.out.lpcbSecurityDescriptor;
8859 0 : *state->orig.out.lpftLastWriteTime = *state->tmp.out.lpftLastWriteTime;
8860 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
8861 :
8862 : /* Copy result */
8863 0 : state->orig.out.result = state->tmp.out.result;
8864 :
8865 : /* Reset temporary structure */
8866 0 : NDR_ZERO_STRUCT(state->tmp);
8867 :
8868 0 : tevent_req_done(req);
8869 : }
8870 :
8871 0 : NTSTATUS dcerpc_clusapi_QueryInfoKey_recv(struct tevent_req *req,
8872 : TALLOC_CTX *mem_ctx,
8873 : WERROR *result)
8874 : {
8875 0 : struct dcerpc_clusapi_QueryInfoKey_state *state = tevent_req_data(
8876 : req, struct dcerpc_clusapi_QueryInfoKey_state);
8877 : NTSTATUS status;
8878 :
8879 0 : if (tevent_req_is_nterror(req, &status)) {
8880 0 : tevent_req_received(req);
8881 0 : return status;
8882 : }
8883 :
8884 : /* Steal possible out parameters to the callers context */
8885 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
8886 :
8887 : /* Return result */
8888 0 : *result = state->orig.out.result;
8889 :
8890 0 : tevent_req_received(req);
8891 0 : return NT_STATUS_OK;
8892 : }
8893 :
8894 0 : NTSTATUS dcerpc_clusapi_QueryInfoKey(struct dcerpc_binding_handle *h,
8895 : TALLOC_CTX *mem_ctx,
8896 : struct policy_handle _hKey /* [in] */,
8897 : uint32_t *_lpcSubKeys /* [out] [ref] */,
8898 : uint32_t *_lpcbMaxSubKeyLen /* [out] [ref] */,
8899 : uint32_t *_lpcValues /* [out] [ref] */,
8900 : uint32_t *_lpcbMaxValueNameLen /* [out] [ref] */,
8901 : uint32_t *_lpcbMaxValueLen /* [out] [ref] */,
8902 : uint32_t *_lpcbSecurityDescriptor /* [out] [ref] */,
8903 : NTTIME *_lpftLastWriteTime /* [out] [ref] */,
8904 : WERROR *_rpc_status /* [out] [ref] */,
8905 : WERROR *result)
8906 : {
8907 : struct clusapi_QueryInfoKey r;
8908 : NTSTATUS status;
8909 :
8910 : /* In parameters */
8911 0 : r.in.hKey = _hKey;
8912 :
8913 : /* Out parameters */
8914 0 : r.out.lpcSubKeys = _lpcSubKeys;
8915 0 : r.out.lpcbMaxSubKeyLen = _lpcbMaxSubKeyLen;
8916 0 : r.out.lpcValues = _lpcValues;
8917 0 : r.out.lpcbMaxValueNameLen = _lpcbMaxValueNameLen;
8918 0 : r.out.lpcbMaxValueLen = _lpcbMaxValueLen;
8919 0 : r.out.lpcbSecurityDescriptor = _lpcbSecurityDescriptor;
8920 0 : r.out.lpftLastWriteTime = _lpftLastWriteTime;
8921 0 : r.out.rpc_status = _rpc_status;
8922 :
8923 : /* Result */
8924 0 : NDR_ZERO_STRUCT(r.out.result);
8925 :
8926 0 : status = dcerpc_clusapi_QueryInfoKey_r(h, mem_ctx, &r);
8927 0 : if (!NT_STATUS_IS_OK(status)) {
8928 0 : return status;
8929 : }
8930 :
8931 : /* Return variables */
8932 0 : *_lpcSubKeys = *r.out.lpcSubKeys;
8933 0 : *_lpcbMaxSubKeyLen = *r.out.lpcbMaxSubKeyLen;
8934 0 : *_lpcValues = *r.out.lpcValues;
8935 0 : *_lpcbMaxValueNameLen = *r.out.lpcbMaxValueNameLen;
8936 0 : *_lpcbMaxValueLen = *r.out.lpcbMaxValueLen;
8937 0 : *_lpcbSecurityDescriptor = *r.out.lpcbSecurityDescriptor;
8938 0 : *_lpftLastWriteTime = *r.out.lpftLastWriteTime;
8939 0 : *_rpc_status = *r.out.rpc_status;
8940 :
8941 : /* Return result */
8942 0 : *result = r.out.result;
8943 :
8944 0 : return NT_STATUS_OK;
8945 : }
8946 :
8947 : struct dcerpc_clusapi_SetKeySecurity_r_state {
8948 : TALLOC_CTX *out_mem_ctx;
8949 : };
8950 :
8951 : static void dcerpc_clusapi_SetKeySecurity_r_done(struct tevent_req *subreq);
8952 :
8953 0 : struct tevent_req *dcerpc_clusapi_SetKeySecurity_r_send(TALLOC_CTX *mem_ctx,
8954 : struct tevent_context *ev,
8955 : struct dcerpc_binding_handle *h,
8956 : struct clusapi_SetKeySecurity *r)
8957 : {
8958 : struct tevent_req *req;
8959 : struct dcerpc_clusapi_SetKeySecurity_r_state *state;
8960 : struct tevent_req *subreq;
8961 :
8962 0 : req = tevent_req_create(mem_ctx, &state,
8963 : struct dcerpc_clusapi_SetKeySecurity_r_state);
8964 0 : if (req == NULL) {
8965 0 : return NULL;
8966 : }
8967 :
8968 0 : state->out_mem_ctx = talloc_new(state);
8969 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
8970 0 : return tevent_req_post(req, ev);
8971 : }
8972 :
8973 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
8974 : NULL, &ndr_table_clusapi,
8975 0 : NDR_CLUSAPI_SETKEYSECURITY, state->out_mem_ctx, r);
8976 0 : if (tevent_req_nomem(subreq, req)) {
8977 0 : return tevent_req_post(req, ev);
8978 : }
8979 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetKeySecurity_r_done, req);
8980 :
8981 0 : return req;
8982 : }
8983 :
8984 0 : static void dcerpc_clusapi_SetKeySecurity_r_done(struct tevent_req *subreq)
8985 : {
8986 0 : struct tevent_req *req =
8987 0 : tevent_req_callback_data(subreq,
8988 : struct tevent_req);
8989 : NTSTATUS status;
8990 :
8991 0 : status = dcerpc_binding_handle_call_recv(subreq);
8992 0 : TALLOC_FREE(subreq);
8993 0 : if (tevent_req_nterror(req, status)) {
8994 0 : return;
8995 : }
8996 :
8997 0 : tevent_req_done(req);
8998 : }
8999 :
9000 0 : NTSTATUS dcerpc_clusapi_SetKeySecurity_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9001 : {
9002 0 : struct dcerpc_clusapi_SetKeySecurity_r_state *state =
9003 0 : tevent_req_data(req,
9004 : struct dcerpc_clusapi_SetKeySecurity_r_state);
9005 : NTSTATUS status;
9006 :
9007 0 : if (tevent_req_is_nterror(req, &status)) {
9008 0 : tevent_req_received(req);
9009 0 : return status;
9010 : }
9011 :
9012 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9013 :
9014 0 : tevent_req_received(req);
9015 0 : return NT_STATUS_OK;
9016 : }
9017 :
9018 0 : NTSTATUS dcerpc_clusapi_SetKeySecurity_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetKeySecurity *r)
9019 : {
9020 : NTSTATUS status;
9021 :
9022 0 : status = dcerpc_binding_handle_call(h,
9023 : NULL, &ndr_table_clusapi,
9024 : NDR_CLUSAPI_SETKEYSECURITY, mem_ctx, r);
9025 :
9026 0 : return status;
9027 : }
9028 :
9029 : struct dcerpc_clusapi_SetKeySecurity_state {
9030 : struct clusapi_SetKeySecurity orig;
9031 : struct clusapi_SetKeySecurity tmp;
9032 : TALLOC_CTX *out_mem_ctx;
9033 : };
9034 :
9035 : static void dcerpc_clusapi_SetKeySecurity_done(struct tevent_req *subreq);
9036 :
9037 0 : struct tevent_req *dcerpc_clusapi_SetKeySecurity_send(TALLOC_CTX *mem_ctx,
9038 : struct tevent_context *ev,
9039 : struct dcerpc_binding_handle *h,
9040 : struct policy_handle _hKey /* [in] */,
9041 : uint32_t _SecurityInformation /* [in] */,
9042 : struct RPC_SECURITY_DESCRIPTOR *_pRpcSecurityDescriptor /* [in] [ref] */,
9043 : WERROR *_rpc_status /* [out] [ref] */)
9044 : {
9045 : struct tevent_req *req;
9046 : struct dcerpc_clusapi_SetKeySecurity_state *state;
9047 : struct tevent_req *subreq;
9048 :
9049 0 : req = tevent_req_create(mem_ctx, &state,
9050 : struct dcerpc_clusapi_SetKeySecurity_state);
9051 0 : if (req == NULL) {
9052 0 : return NULL;
9053 : }
9054 0 : state->out_mem_ctx = NULL;
9055 :
9056 : /* In parameters */
9057 0 : state->orig.in.hKey = _hKey;
9058 0 : state->orig.in.SecurityInformation = _SecurityInformation;
9059 0 : state->orig.in.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9060 :
9061 : /* Out parameters */
9062 0 : state->orig.out.rpc_status = _rpc_status;
9063 :
9064 : /* Result */
9065 0 : NDR_ZERO_STRUCT(state->orig.out.result);
9066 :
9067 0 : state->out_mem_ctx = talloc_named_const(state, 0,
9068 : "dcerpc_clusapi_SetKeySecurity_out_memory");
9069 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9070 0 : return tevent_req_post(req, ev);
9071 : }
9072 :
9073 : /* make a temporary copy, that we pass to the dispatch function */
9074 0 : state->tmp = state->orig;
9075 :
9076 0 : subreq = dcerpc_clusapi_SetKeySecurity_r_send(state, ev, h, &state->tmp);
9077 0 : if (tevent_req_nomem(subreq, req)) {
9078 0 : return tevent_req_post(req, ev);
9079 : }
9080 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetKeySecurity_done, req);
9081 0 : return req;
9082 : }
9083 :
9084 0 : static void dcerpc_clusapi_SetKeySecurity_done(struct tevent_req *subreq)
9085 : {
9086 0 : struct tevent_req *req = tevent_req_callback_data(
9087 : subreq, struct tevent_req);
9088 0 : struct dcerpc_clusapi_SetKeySecurity_state *state = tevent_req_data(
9089 : req, struct dcerpc_clusapi_SetKeySecurity_state);
9090 : NTSTATUS status;
9091 : TALLOC_CTX *mem_ctx;
9092 :
9093 0 : if (state->out_mem_ctx) {
9094 0 : mem_ctx = state->out_mem_ctx;
9095 : } else {
9096 0 : mem_ctx = state;
9097 : }
9098 :
9099 0 : status = dcerpc_clusapi_SetKeySecurity_r_recv(subreq, mem_ctx);
9100 0 : TALLOC_FREE(subreq);
9101 0 : if (tevent_req_nterror(req, status)) {
9102 0 : return;
9103 : }
9104 :
9105 : /* Copy out parameters */
9106 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
9107 :
9108 : /* Copy result */
9109 0 : state->orig.out.result = state->tmp.out.result;
9110 :
9111 : /* Reset temporary structure */
9112 0 : NDR_ZERO_STRUCT(state->tmp);
9113 :
9114 0 : tevent_req_done(req);
9115 : }
9116 :
9117 0 : NTSTATUS dcerpc_clusapi_SetKeySecurity_recv(struct tevent_req *req,
9118 : TALLOC_CTX *mem_ctx,
9119 : WERROR *result)
9120 : {
9121 0 : struct dcerpc_clusapi_SetKeySecurity_state *state = tevent_req_data(
9122 : req, struct dcerpc_clusapi_SetKeySecurity_state);
9123 : NTSTATUS status;
9124 :
9125 0 : if (tevent_req_is_nterror(req, &status)) {
9126 0 : tevent_req_received(req);
9127 0 : return status;
9128 : }
9129 :
9130 : /* Steal possible out parameters to the callers context */
9131 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9132 :
9133 : /* Return result */
9134 0 : *result = state->orig.out.result;
9135 :
9136 0 : tevent_req_received(req);
9137 0 : return NT_STATUS_OK;
9138 : }
9139 :
9140 0 : NTSTATUS dcerpc_clusapi_SetKeySecurity(struct dcerpc_binding_handle *h,
9141 : TALLOC_CTX *mem_ctx,
9142 : struct policy_handle _hKey /* [in] */,
9143 : uint32_t _SecurityInformation /* [in] */,
9144 : struct RPC_SECURITY_DESCRIPTOR *_pRpcSecurityDescriptor /* [in] [ref] */,
9145 : WERROR *_rpc_status /* [out] [ref] */,
9146 : WERROR *result)
9147 : {
9148 : struct clusapi_SetKeySecurity r;
9149 : NTSTATUS status;
9150 :
9151 : /* In parameters */
9152 0 : r.in.hKey = _hKey;
9153 0 : r.in.SecurityInformation = _SecurityInformation;
9154 0 : r.in.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9155 :
9156 : /* Out parameters */
9157 0 : r.out.rpc_status = _rpc_status;
9158 :
9159 : /* Result */
9160 0 : NDR_ZERO_STRUCT(r.out.result);
9161 :
9162 0 : status = dcerpc_clusapi_SetKeySecurity_r(h, mem_ctx, &r);
9163 0 : if (!NT_STATUS_IS_OK(status)) {
9164 0 : return status;
9165 : }
9166 :
9167 : /* Return variables */
9168 0 : *_rpc_status = *r.out.rpc_status;
9169 :
9170 : /* Return result */
9171 0 : *result = r.out.result;
9172 :
9173 0 : return NT_STATUS_OK;
9174 : }
9175 :
9176 : struct dcerpc_clusapi_GetKeySecurity_r_state {
9177 : TALLOC_CTX *out_mem_ctx;
9178 : };
9179 :
9180 : static void dcerpc_clusapi_GetKeySecurity_r_done(struct tevent_req *subreq);
9181 :
9182 0 : struct tevent_req *dcerpc_clusapi_GetKeySecurity_r_send(TALLOC_CTX *mem_ctx,
9183 : struct tevent_context *ev,
9184 : struct dcerpc_binding_handle *h,
9185 : struct clusapi_GetKeySecurity *r)
9186 : {
9187 : struct tevent_req *req;
9188 : struct dcerpc_clusapi_GetKeySecurity_r_state *state;
9189 : struct tevent_req *subreq;
9190 :
9191 0 : req = tevent_req_create(mem_ctx, &state,
9192 : struct dcerpc_clusapi_GetKeySecurity_r_state);
9193 0 : if (req == NULL) {
9194 0 : return NULL;
9195 : }
9196 :
9197 0 : state->out_mem_ctx = talloc_new(state);
9198 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9199 0 : return tevent_req_post(req, ev);
9200 : }
9201 :
9202 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
9203 : NULL, &ndr_table_clusapi,
9204 0 : NDR_CLUSAPI_GETKEYSECURITY, state->out_mem_ctx, r);
9205 0 : if (tevent_req_nomem(subreq, req)) {
9206 0 : return tevent_req_post(req, ev);
9207 : }
9208 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetKeySecurity_r_done, req);
9209 :
9210 0 : return req;
9211 : }
9212 :
9213 0 : static void dcerpc_clusapi_GetKeySecurity_r_done(struct tevent_req *subreq)
9214 : {
9215 0 : struct tevent_req *req =
9216 0 : tevent_req_callback_data(subreq,
9217 : struct tevent_req);
9218 : NTSTATUS status;
9219 :
9220 0 : status = dcerpc_binding_handle_call_recv(subreq);
9221 0 : TALLOC_FREE(subreq);
9222 0 : if (tevent_req_nterror(req, status)) {
9223 0 : return;
9224 : }
9225 :
9226 0 : tevent_req_done(req);
9227 : }
9228 :
9229 0 : NTSTATUS dcerpc_clusapi_GetKeySecurity_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9230 : {
9231 0 : struct dcerpc_clusapi_GetKeySecurity_r_state *state =
9232 0 : tevent_req_data(req,
9233 : struct dcerpc_clusapi_GetKeySecurity_r_state);
9234 : NTSTATUS status;
9235 :
9236 0 : if (tevent_req_is_nterror(req, &status)) {
9237 0 : tevent_req_received(req);
9238 0 : return status;
9239 : }
9240 :
9241 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9242 :
9243 0 : tevent_req_received(req);
9244 0 : return NT_STATUS_OK;
9245 : }
9246 :
9247 0 : NTSTATUS dcerpc_clusapi_GetKeySecurity_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetKeySecurity *r)
9248 : {
9249 : NTSTATUS status;
9250 :
9251 0 : status = dcerpc_binding_handle_call(h,
9252 : NULL, &ndr_table_clusapi,
9253 : NDR_CLUSAPI_GETKEYSECURITY, mem_ctx, r);
9254 :
9255 0 : return status;
9256 : }
9257 :
9258 : struct dcerpc_clusapi_GetKeySecurity_state {
9259 : struct clusapi_GetKeySecurity orig;
9260 : struct clusapi_GetKeySecurity tmp;
9261 : TALLOC_CTX *out_mem_ctx;
9262 : };
9263 :
9264 : static void dcerpc_clusapi_GetKeySecurity_done(struct tevent_req *subreq);
9265 :
9266 0 : struct tevent_req *dcerpc_clusapi_GetKeySecurity_send(TALLOC_CTX *mem_ctx,
9267 : struct tevent_context *ev,
9268 : struct dcerpc_binding_handle *h,
9269 : struct policy_handle _hKey /* [in] */,
9270 : uint32_t _SecurityInformation /* [in] */,
9271 : struct RPC_SECURITY_DESCRIPTOR *_pRpcSecurityDescriptor /* [in,out] [ref] */,
9272 : WERROR *_rpc_status /* [out] [ref] */)
9273 : {
9274 : struct tevent_req *req;
9275 : struct dcerpc_clusapi_GetKeySecurity_state *state;
9276 : struct tevent_req *subreq;
9277 :
9278 0 : req = tevent_req_create(mem_ctx, &state,
9279 : struct dcerpc_clusapi_GetKeySecurity_state);
9280 0 : if (req == NULL) {
9281 0 : return NULL;
9282 : }
9283 0 : state->out_mem_ctx = NULL;
9284 :
9285 : /* In parameters */
9286 0 : state->orig.in.hKey = _hKey;
9287 0 : state->orig.in.SecurityInformation = _SecurityInformation;
9288 0 : state->orig.in.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9289 :
9290 : /* Out parameters */
9291 0 : state->orig.out.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9292 0 : state->orig.out.rpc_status = _rpc_status;
9293 :
9294 : /* Result */
9295 0 : NDR_ZERO_STRUCT(state->orig.out.result);
9296 :
9297 0 : state->out_mem_ctx = talloc_named_const(state, 0,
9298 : "dcerpc_clusapi_GetKeySecurity_out_memory");
9299 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9300 0 : return tevent_req_post(req, ev);
9301 : }
9302 :
9303 : /* make a temporary copy, that we pass to the dispatch function */
9304 0 : state->tmp = state->orig;
9305 :
9306 0 : subreq = dcerpc_clusapi_GetKeySecurity_r_send(state, ev, h, &state->tmp);
9307 0 : if (tevent_req_nomem(subreq, req)) {
9308 0 : return tevent_req_post(req, ev);
9309 : }
9310 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetKeySecurity_done, req);
9311 0 : return req;
9312 : }
9313 :
9314 0 : static void dcerpc_clusapi_GetKeySecurity_done(struct tevent_req *subreq)
9315 : {
9316 0 : struct tevent_req *req = tevent_req_callback_data(
9317 : subreq, struct tevent_req);
9318 0 : struct dcerpc_clusapi_GetKeySecurity_state *state = tevent_req_data(
9319 : req, struct dcerpc_clusapi_GetKeySecurity_state);
9320 : NTSTATUS status;
9321 : TALLOC_CTX *mem_ctx;
9322 :
9323 0 : if (state->out_mem_ctx) {
9324 0 : mem_ctx = state->out_mem_ctx;
9325 : } else {
9326 0 : mem_ctx = state;
9327 : }
9328 :
9329 0 : status = dcerpc_clusapi_GetKeySecurity_r_recv(subreq, mem_ctx);
9330 0 : TALLOC_FREE(subreq);
9331 0 : if (tevent_req_nterror(req, status)) {
9332 0 : return;
9333 : }
9334 :
9335 : /* Copy out parameters */
9336 0 : *state->orig.out.pRpcSecurityDescriptor = *state->tmp.out.pRpcSecurityDescriptor;
9337 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
9338 :
9339 : /* Copy result */
9340 0 : state->orig.out.result = state->tmp.out.result;
9341 :
9342 : /* Reset temporary structure */
9343 0 : NDR_ZERO_STRUCT(state->tmp);
9344 :
9345 0 : tevent_req_done(req);
9346 : }
9347 :
9348 0 : NTSTATUS dcerpc_clusapi_GetKeySecurity_recv(struct tevent_req *req,
9349 : TALLOC_CTX *mem_ctx,
9350 : WERROR *result)
9351 : {
9352 0 : struct dcerpc_clusapi_GetKeySecurity_state *state = tevent_req_data(
9353 : req, struct dcerpc_clusapi_GetKeySecurity_state);
9354 : NTSTATUS status;
9355 :
9356 0 : if (tevent_req_is_nterror(req, &status)) {
9357 0 : tevent_req_received(req);
9358 0 : return status;
9359 : }
9360 :
9361 : /* Steal possible out parameters to the callers context */
9362 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9363 :
9364 : /* Return result */
9365 0 : *result = state->orig.out.result;
9366 :
9367 0 : tevent_req_received(req);
9368 0 : return NT_STATUS_OK;
9369 : }
9370 :
9371 0 : NTSTATUS dcerpc_clusapi_GetKeySecurity(struct dcerpc_binding_handle *h,
9372 : TALLOC_CTX *mem_ctx,
9373 : struct policy_handle _hKey /* [in] */,
9374 : uint32_t _SecurityInformation /* [in] */,
9375 : struct RPC_SECURITY_DESCRIPTOR *_pRpcSecurityDescriptor /* [in,out] [ref] */,
9376 : WERROR *_rpc_status /* [out] [ref] */,
9377 : WERROR *result)
9378 : {
9379 : struct clusapi_GetKeySecurity r;
9380 : NTSTATUS status;
9381 :
9382 : /* In parameters */
9383 0 : r.in.hKey = _hKey;
9384 0 : r.in.SecurityInformation = _SecurityInformation;
9385 0 : r.in.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9386 :
9387 : /* Out parameters */
9388 0 : r.out.pRpcSecurityDescriptor = _pRpcSecurityDescriptor;
9389 0 : r.out.rpc_status = _rpc_status;
9390 :
9391 : /* Result */
9392 0 : NDR_ZERO_STRUCT(r.out.result);
9393 :
9394 0 : status = dcerpc_clusapi_GetKeySecurity_r(h, mem_ctx, &r);
9395 0 : if (!NT_STATUS_IS_OK(status)) {
9396 0 : return status;
9397 : }
9398 :
9399 : /* Return variables */
9400 0 : *_pRpcSecurityDescriptor = *r.out.pRpcSecurityDescriptor;
9401 0 : *_rpc_status = *r.out.rpc_status;
9402 :
9403 : /* Return result */
9404 0 : *result = r.out.result;
9405 :
9406 0 : return NT_STATUS_OK;
9407 : }
9408 :
9409 : struct dcerpc_clusapi_OpenGroup_r_state {
9410 : TALLOC_CTX *out_mem_ctx;
9411 : };
9412 :
9413 : static void dcerpc_clusapi_OpenGroup_r_done(struct tevent_req *subreq);
9414 :
9415 0 : struct tevent_req *dcerpc_clusapi_OpenGroup_r_send(TALLOC_CTX *mem_ctx,
9416 : struct tevent_context *ev,
9417 : struct dcerpc_binding_handle *h,
9418 : struct clusapi_OpenGroup *r)
9419 : {
9420 : struct tevent_req *req;
9421 : struct dcerpc_clusapi_OpenGroup_r_state *state;
9422 : struct tevent_req *subreq;
9423 :
9424 0 : req = tevent_req_create(mem_ctx, &state,
9425 : struct dcerpc_clusapi_OpenGroup_r_state);
9426 0 : if (req == NULL) {
9427 0 : return NULL;
9428 : }
9429 :
9430 0 : state->out_mem_ctx = talloc_new(state);
9431 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9432 0 : return tevent_req_post(req, ev);
9433 : }
9434 :
9435 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
9436 : NULL, &ndr_table_clusapi,
9437 0 : NDR_CLUSAPI_OPENGROUP, state->out_mem_ctx, r);
9438 0 : if (tevent_req_nomem(subreq, req)) {
9439 0 : return tevent_req_post(req, ev);
9440 : }
9441 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroup_r_done, req);
9442 :
9443 0 : return req;
9444 : }
9445 :
9446 0 : static void dcerpc_clusapi_OpenGroup_r_done(struct tevent_req *subreq)
9447 : {
9448 0 : struct tevent_req *req =
9449 0 : tevent_req_callback_data(subreq,
9450 : struct tevent_req);
9451 : NTSTATUS status;
9452 :
9453 0 : status = dcerpc_binding_handle_call_recv(subreq);
9454 0 : TALLOC_FREE(subreq);
9455 0 : if (tevent_req_nterror(req, status)) {
9456 0 : return;
9457 : }
9458 :
9459 0 : tevent_req_done(req);
9460 : }
9461 :
9462 0 : NTSTATUS dcerpc_clusapi_OpenGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9463 : {
9464 0 : struct dcerpc_clusapi_OpenGroup_r_state *state =
9465 0 : tevent_req_data(req,
9466 : struct dcerpc_clusapi_OpenGroup_r_state);
9467 : NTSTATUS status;
9468 :
9469 0 : if (tevent_req_is_nterror(req, &status)) {
9470 0 : tevent_req_received(req);
9471 0 : return status;
9472 : }
9473 :
9474 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9475 :
9476 0 : tevent_req_received(req);
9477 0 : return NT_STATUS_OK;
9478 : }
9479 :
9480 0 : NTSTATUS dcerpc_clusapi_OpenGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenGroup *r)
9481 : {
9482 : NTSTATUS status;
9483 :
9484 0 : status = dcerpc_binding_handle_call(h,
9485 : NULL, &ndr_table_clusapi,
9486 : NDR_CLUSAPI_OPENGROUP, mem_ctx, r);
9487 :
9488 0 : return status;
9489 : }
9490 :
9491 : struct dcerpc_clusapi_OpenGroup_state {
9492 : struct clusapi_OpenGroup orig;
9493 : struct clusapi_OpenGroup tmp;
9494 : TALLOC_CTX *out_mem_ctx;
9495 : };
9496 :
9497 : static void dcerpc_clusapi_OpenGroup_done(struct tevent_req *subreq);
9498 :
9499 0 : struct tevent_req *dcerpc_clusapi_OpenGroup_send(TALLOC_CTX *mem_ctx,
9500 : struct tevent_context *ev,
9501 : struct dcerpc_binding_handle *h,
9502 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
9503 : WERROR *_Status /* [out] [ref] */,
9504 : WERROR *_rpc_status /* [out] [ref] */,
9505 : struct policy_handle *_hGroup /* [out] [ref] */)
9506 : {
9507 : struct tevent_req *req;
9508 : struct dcerpc_clusapi_OpenGroup_state *state;
9509 : struct tevent_req *subreq;
9510 :
9511 0 : req = tevent_req_create(mem_ctx, &state,
9512 : struct dcerpc_clusapi_OpenGroup_state);
9513 0 : if (req == NULL) {
9514 0 : return NULL;
9515 : }
9516 0 : state->out_mem_ctx = NULL;
9517 :
9518 : /* In parameters */
9519 0 : state->orig.in.lpszGroupName = _lpszGroupName;
9520 :
9521 : /* Out parameters */
9522 0 : state->orig.out.Status = _Status;
9523 0 : state->orig.out.rpc_status = _rpc_status;
9524 0 : state->orig.out.hGroup = _hGroup;
9525 :
9526 0 : state->out_mem_ctx = talloc_named_const(state, 0,
9527 : "dcerpc_clusapi_OpenGroup_out_memory");
9528 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9529 0 : return tevent_req_post(req, ev);
9530 : }
9531 :
9532 : /* make a temporary copy, that we pass to the dispatch function */
9533 0 : state->tmp = state->orig;
9534 :
9535 0 : subreq = dcerpc_clusapi_OpenGroup_r_send(state, ev, h, &state->tmp);
9536 0 : if (tevent_req_nomem(subreq, req)) {
9537 0 : return tevent_req_post(req, ev);
9538 : }
9539 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroup_done, req);
9540 0 : return req;
9541 : }
9542 :
9543 0 : static void dcerpc_clusapi_OpenGroup_done(struct tevent_req *subreq)
9544 : {
9545 0 : struct tevent_req *req = tevent_req_callback_data(
9546 : subreq, struct tevent_req);
9547 0 : struct dcerpc_clusapi_OpenGroup_state *state = tevent_req_data(
9548 : req, struct dcerpc_clusapi_OpenGroup_state);
9549 : NTSTATUS status;
9550 : TALLOC_CTX *mem_ctx;
9551 :
9552 0 : if (state->out_mem_ctx) {
9553 0 : mem_ctx = state->out_mem_ctx;
9554 : } else {
9555 0 : mem_ctx = state;
9556 : }
9557 :
9558 0 : status = dcerpc_clusapi_OpenGroup_r_recv(subreq, mem_ctx);
9559 0 : TALLOC_FREE(subreq);
9560 0 : if (tevent_req_nterror(req, status)) {
9561 0 : return;
9562 : }
9563 :
9564 : /* Copy out parameters */
9565 0 : *state->orig.out.Status = *state->tmp.out.Status;
9566 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
9567 0 : *state->orig.out.hGroup = *state->tmp.out.hGroup;
9568 :
9569 : /* Reset temporary structure */
9570 0 : NDR_ZERO_STRUCT(state->tmp);
9571 :
9572 0 : tevent_req_done(req);
9573 : }
9574 :
9575 0 : NTSTATUS dcerpc_clusapi_OpenGroup_recv(struct tevent_req *req,
9576 : TALLOC_CTX *mem_ctx)
9577 : {
9578 0 : struct dcerpc_clusapi_OpenGroup_state *state = tevent_req_data(
9579 : req, struct dcerpc_clusapi_OpenGroup_state);
9580 : NTSTATUS status;
9581 :
9582 0 : if (tevent_req_is_nterror(req, &status)) {
9583 0 : tevent_req_received(req);
9584 0 : return status;
9585 : }
9586 :
9587 : /* Steal possible out parameters to the callers context */
9588 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9589 :
9590 0 : tevent_req_received(req);
9591 0 : return NT_STATUS_OK;
9592 : }
9593 :
9594 0 : NTSTATUS dcerpc_clusapi_OpenGroup(struct dcerpc_binding_handle *h,
9595 : TALLOC_CTX *mem_ctx,
9596 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
9597 : WERROR *_Status /* [out] [ref] */,
9598 : WERROR *_rpc_status /* [out] [ref] */,
9599 : struct policy_handle *_hGroup /* [out] [ref] */)
9600 : {
9601 : struct clusapi_OpenGroup r;
9602 : NTSTATUS status;
9603 :
9604 : /* In parameters */
9605 0 : r.in.lpszGroupName = _lpszGroupName;
9606 :
9607 : /* Out parameters */
9608 0 : r.out.Status = _Status;
9609 0 : r.out.rpc_status = _rpc_status;
9610 0 : r.out.hGroup = _hGroup;
9611 :
9612 0 : status = dcerpc_clusapi_OpenGroup_r(h, mem_ctx, &r);
9613 0 : if (!NT_STATUS_IS_OK(status)) {
9614 0 : return status;
9615 : }
9616 :
9617 : /* Return variables */
9618 0 : *_Status = *r.out.Status;
9619 0 : *_rpc_status = *r.out.rpc_status;
9620 0 : *_hGroup = *r.out.hGroup;
9621 :
9622 : /* Return result */
9623 :
9624 0 : return NT_STATUS_OK;
9625 : }
9626 :
9627 : struct dcerpc_clusapi_CreateGroup_r_state {
9628 : TALLOC_CTX *out_mem_ctx;
9629 : };
9630 :
9631 : static void dcerpc_clusapi_CreateGroup_r_done(struct tevent_req *subreq);
9632 :
9633 0 : struct tevent_req *dcerpc_clusapi_CreateGroup_r_send(TALLOC_CTX *mem_ctx,
9634 : struct tevent_context *ev,
9635 : struct dcerpc_binding_handle *h,
9636 : struct clusapi_CreateGroup *r)
9637 : {
9638 : struct tevent_req *req;
9639 : struct dcerpc_clusapi_CreateGroup_r_state *state;
9640 : struct tevent_req *subreq;
9641 :
9642 0 : req = tevent_req_create(mem_ctx, &state,
9643 : struct dcerpc_clusapi_CreateGroup_r_state);
9644 0 : if (req == NULL) {
9645 0 : return NULL;
9646 : }
9647 :
9648 0 : state->out_mem_ctx = talloc_new(state);
9649 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9650 0 : return tevent_req_post(req, ev);
9651 : }
9652 :
9653 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
9654 : NULL, &ndr_table_clusapi,
9655 0 : NDR_CLUSAPI_CREATEGROUP, state->out_mem_ctx, r);
9656 0 : if (tevent_req_nomem(subreq, req)) {
9657 0 : return tevent_req_post(req, ev);
9658 : }
9659 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroup_r_done, req);
9660 :
9661 0 : return req;
9662 : }
9663 :
9664 0 : static void dcerpc_clusapi_CreateGroup_r_done(struct tevent_req *subreq)
9665 : {
9666 0 : struct tevent_req *req =
9667 0 : tevent_req_callback_data(subreq,
9668 : struct tevent_req);
9669 : NTSTATUS status;
9670 :
9671 0 : status = dcerpc_binding_handle_call_recv(subreq);
9672 0 : TALLOC_FREE(subreq);
9673 0 : if (tevent_req_nterror(req, status)) {
9674 0 : return;
9675 : }
9676 :
9677 0 : tevent_req_done(req);
9678 : }
9679 :
9680 0 : NTSTATUS dcerpc_clusapi_CreateGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9681 : {
9682 0 : struct dcerpc_clusapi_CreateGroup_r_state *state =
9683 0 : tevent_req_data(req,
9684 : struct dcerpc_clusapi_CreateGroup_r_state);
9685 : NTSTATUS status;
9686 :
9687 0 : if (tevent_req_is_nterror(req, &status)) {
9688 0 : tevent_req_received(req);
9689 0 : return status;
9690 : }
9691 :
9692 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9693 :
9694 0 : tevent_req_received(req);
9695 0 : return NT_STATUS_OK;
9696 : }
9697 :
9698 0 : NTSTATUS dcerpc_clusapi_CreateGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroup *r)
9699 : {
9700 : NTSTATUS status;
9701 :
9702 0 : status = dcerpc_binding_handle_call(h,
9703 : NULL, &ndr_table_clusapi,
9704 : NDR_CLUSAPI_CREATEGROUP, mem_ctx, r);
9705 :
9706 0 : return status;
9707 : }
9708 :
9709 : struct dcerpc_clusapi_CreateGroup_state {
9710 : struct clusapi_CreateGroup orig;
9711 : struct clusapi_CreateGroup tmp;
9712 : TALLOC_CTX *out_mem_ctx;
9713 : };
9714 :
9715 : static void dcerpc_clusapi_CreateGroup_done(struct tevent_req *subreq);
9716 :
9717 0 : struct tevent_req *dcerpc_clusapi_CreateGroup_send(TALLOC_CTX *mem_ctx,
9718 : struct tevent_context *ev,
9719 : struct dcerpc_binding_handle *h,
9720 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
9721 : WERROR *_Status /* [out] [ref] */,
9722 : WERROR *_rpc_status /* [out] [ref] */,
9723 : struct policy_handle *_hGroup /* [out] [ref] */)
9724 : {
9725 : struct tevent_req *req;
9726 : struct dcerpc_clusapi_CreateGroup_state *state;
9727 : struct tevent_req *subreq;
9728 :
9729 0 : req = tevent_req_create(mem_ctx, &state,
9730 : struct dcerpc_clusapi_CreateGroup_state);
9731 0 : if (req == NULL) {
9732 0 : return NULL;
9733 : }
9734 0 : state->out_mem_ctx = NULL;
9735 :
9736 : /* In parameters */
9737 0 : state->orig.in.lpszGroupName = _lpszGroupName;
9738 :
9739 : /* Out parameters */
9740 0 : state->orig.out.Status = _Status;
9741 0 : state->orig.out.rpc_status = _rpc_status;
9742 0 : state->orig.out.hGroup = _hGroup;
9743 :
9744 0 : state->out_mem_ctx = talloc_named_const(state, 0,
9745 : "dcerpc_clusapi_CreateGroup_out_memory");
9746 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9747 0 : return tevent_req_post(req, ev);
9748 : }
9749 :
9750 : /* make a temporary copy, that we pass to the dispatch function */
9751 0 : state->tmp = state->orig;
9752 :
9753 0 : subreq = dcerpc_clusapi_CreateGroup_r_send(state, ev, h, &state->tmp);
9754 0 : if (tevent_req_nomem(subreq, req)) {
9755 0 : return tevent_req_post(req, ev);
9756 : }
9757 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroup_done, req);
9758 0 : return req;
9759 : }
9760 :
9761 0 : static void dcerpc_clusapi_CreateGroup_done(struct tevent_req *subreq)
9762 : {
9763 0 : struct tevent_req *req = tevent_req_callback_data(
9764 : subreq, struct tevent_req);
9765 0 : struct dcerpc_clusapi_CreateGroup_state *state = tevent_req_data(
9766 : req, struct dcerpc_clusapi_CreateGroup_state);
9767 : NTSTATUS status;
9768 : TALLOC_CTX *mem_ctx;
9769 :
9770 0 : if (state->out_mem_ctx) {
9771 0 : mem_ctx = state->out_mem_ctx;
9772 : } else {
9773 0 : mem_ctx = state;
9774 : }
9775 :
9776 0 : status = dcerpc_clusapi_CreateGroup_r_recv(subreq, mem_ctx);
9777 0 : TALLOC_FREE(subreq);
9778 0 : if (tevent_req_nterror(req, status)) {
9779 0 : return;
9780 : }
9781 :
9782 : /* Copy out parameters */
9783 0 : *state->orig.out.Status = *state->tmp.out.Status;
9784 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
9785 0 : *state->orig.out.hGroup = *state->tmp.out.hGroup;
9786 :
9787 : /* Reset temporary structure */
9788 0 : NDR_ZERO_STRUCT(state->tmp);
9789 :
9790 0 : tevent_req_done(req);
9791 : }
9792 :
9793 0 : NTSTATUS dcerpc_clusapi_CreateGroup_recv(struct tevent_req *req,
9794 : TALLOC_CTX *mem_ctx)
9795 : {
9796 0 : struct dcerpc_clusapi_CreateGroup_state *state = tevent_req_data(
9797 : req, struct dcerpc_clusapi_CreateGroup_state);
9798 : NTSTATUS status;
9799 :
9800 0 : if (tevent_req_is_nterror(req, &status)) {
9801 0 : tevent_req_received(req);
9802 0 : return status;
9803 : }
9804 :
9805 : /* Steal possible out parameters to the callers context */
9806 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9807 :
9808 0 : tevent_req_received(req);
9809 0 : return NT_STATUS_OK;
9810 : }
9811 :
9812 0 : NTSTATUS dcerpc_clusapi_CreateGroup(struct dcerpc_binding_handle *h,
9813 : TALLOC_CTX *mem_ctx,
9814 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
9815 : WERROR *_Status /* [out] [ref] */,
9816 : WERROR *_rpc_status /* [out] [ref] */,
9817 : struct policy_handle *_hGroup /* [out] [ref] */)
9818 : {
9819 : struct clusapi_CreateGroup r;
9820 : NTSTATUS status;
9821 :
9822 : /* In parameters */
9823 0 : r.in.lpszGroupName = _lpszGroupName;
9824 :
9825 : /* Out parameters */
9826 0 : r.out.Status = _Status;
9827 0 : r.out.rpc_status = _rpc_status;
9828 0 : r.out.hGroup = _hGroup;
9829 :
9830 0 : status = dcerpc_clusapi_CreateGroup_r(h, mem_ctx, &r);
9831 0 : if (!NT_STATUS_IS_OK(status)) {
9832 0 : return status;
9833 : }
9834 :
9835 : /* Return variables */
9836 0 : *_Status = *r.out.Status;
9837 0 : *_rpc_status = *r.out.rpc_status;
9838 0 : *_hGroup = *r.out.hGroup;
9839 :
9840 : /* Return result */
9841 :
9842 0 : return NT_STATUS_OK;
9843 : }
9844 :
9845 : struct dcerpc_clusapi_DeleteGroup_r_state {
9846 : TALLOC_CTX *out_mem_ctx;
9847 : };
9848 :
9849 : static void dcerpc_clusapi_DeleteGroup_r_done(struct tevent_req *subreq);
9850 :
9851 0 : struct tevent_req *dcerpc_clusapi_DeleteGroup_r_send(TALLOC_CTX *mem_ctx,
9852 : struct tevent_context *ev,
9853 : struct dcerpc_binding_handle *h,
9854 : struct clusapi_DeleteGroup *r)
9855 : {
9856 : struct tevent_req *req;
9857 : struct dcerpc_clusapi_DeleteGroup_r_state *state;
9858 : struct tevent_req *subreq;
9859 :
9860 0 : req = tevent_req_create(mem_ctx, &state,
9861 : struct dcerpc_clusapi_DeleteGroup_r_state);
9862 0 : if (req == NULL) {
9863 0 : return NULL;
9864 : }
9865 :
9866 0 : state->out_mem_ctx = talloc_new(state);
9867 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9868 0 : return tevent_req_post(req, ev);
9869 : }
9870 :
9871 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
9872 : NULL, &ndr_table_clusapi,
9873 0 : NDR_CLUSAPI_DELETEGROUP, state->out_mem_ctx, r);
9874 0 : if (tevent_req_nomem(subreq, req)) {
9875 0 : return tevent_req_post(req, ev);
9876 : }
9877 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteGroup_r_done, req);
9878 :
9879 0 : return req;
9880 : }
9881 :
9882 0 : static void dcerpc_clusapi_DeleteGroup_r_done(struct tevent_req *subreq)
9883 : {
9884 0 : struct tevent_req *req =
9885 0 : tevent_req_callback_data(subreq,
9886 : struct tevent_req);
9887 : NTSTATUS status;
9888 :
9889 0 : status = dcerpc_binding_handle_call_recv(subreq);
9890 0 : TALLOC_FREE(subreq);
9891 0 : if (tevent_req_nterror(req, status)) {
9892 0 : return;
9893 : }
9894 :
9895 0 : tevent_req_done(req);
9896 : }
9897 :
9898 0 : NTSTATUS dcerpc_clusapi_DeleteGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9899 : {
9900 0 : struct dcerpc_clusapi_DeleteGroup_r_state *state =
9901 0 : tevent_req_data(req,
9902 : struct dcerpc_clusapi_DeleteGroup_r_state);
9903 : NTSTATUS status;
9904 :
9905 0 : if (tevent_req_is_nterror(req, &status)) {
9906 0 : tevent_req_received(req);
9907 0 : return status;
9908 : }
9909 :
9910 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
9911 :
9912 0 : tevent_req_received(req);
9913 0 : return NT_STATUS_OK;
9914 : }
9915 :
9916 0 : NTSTATUS dcerpc_clusapi_DeleteGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteGroup *r)
9917 : {
9918 : NTSTATUS status;
9919 :
9920 0 : status = dcerpc_binding_handle_call(h,
9921 : NULL, &ndr_table_clusapi,
9922 : NDR_CLUSAPI_DELETEGROUP, mem_ctx, r);
9923 :
9924 0 : return status;
9925 : }
9926 :
9927 : struct dcerpc_clusapi_DeleteGroup_state {
9928 : struct clusapi_DeleteGroup orig;
9929 : struct clusapi_DeleteGroup tmp;
9930 : TALLOC_CTX *out_mem_ctx;
9931 : };
9932 :
9933 : static void dcerpc_clusapi_DeleteGroup_done(struct tevent_req *subreq);
9934 :
9935 0 : struct tevent_req *dcerpc_clusapi_DeleteGroup_send(TALLOC_CTX *mem_ctx,
9936 : struct tevent_context *ev,
9937 : struct dcerpc_binding_handle *h,
9938 : struct policy_handle _Group /* [in] */,
9939 : uint8_t _force /* [in] */,
9940 : WERROR *_rpc_status /* [out] [ref] */)
9941 : {
9942 : struct tevent_req *req;
9943 : struct dcerpc_clusapi_DeleteGroup_state *state;
9944 : struct tevent_req *subreq;
9945 :
9946 0 : req = tevent_req_create(mem_ctx, &state,
9947 : struct dcerpc_clusapi_DeleteGroup_state);
9948 0 : if (req == NULL) {
9949 0 : return NULL;
9950 : }
9951 0 : state->out_mem_ctx = NULL;
9952 :
9953 : /* In parameters */
9954 0 : state->orig.in.Group = _Group;
9955 0 : state->orig.in.force = _force;
9956 :
9957 : /* Out parameters */
9958 0 : state->orig.out.rpc_status = _rpc_status;
9959 :
9960 : /* Result */
9961 0 : NDR_ZERO_STRUCT(state->orig.out.result);
9962 :
9963 0 : state->out_mem_ctx = talloc_named_const(state, 0,
9964 : "dcerpc_clusapi_DeleteGroup_out_memory");
9965 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
9966 0 : return tevent_req_post(req, ev);
9967 : }
9968 :
9969 : /* make a temporary copy, that we pass to the dispatch function */
9970 0 : state->tmp = state->orig;
9971 :
9972 0 : subreq = dcerpc_clusapi_DeleteGroup_r_send(state, ev, h, &state->tmp);
9973 0 : if (tevent_req_nomem(subreq, req)) {
9974 0 : return tevent_req_post(req, ev);
9975 : }
9976 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteGroup_done, req);
9977 0 : return req;
9978 : }
9979 :
9980 0 : static void dcerpc_clusapi_DeleteGroup_done(struct tevent_req *subreq)
9981 : {
9982 0 : struct tevent_req *req = tevent_req_callback_data(
9983 : subreq, struct tevent_req);
9984 0 : struct dcerpc_clusapi_DeleteGroup_state *state = tevent_req_data(
9985 : req, struct dcerpc_clusapi_DeleteGroup_state);
9986 : NTSTATUS status;
9987 : TALLOC_CTX *mem_ctx;
9988 :
9989 0 : if (state->out_mem_ctx) {
9990 0 : mem_ctx = state->out_mem_ctx;
9991 : } else {
9992 0 : mem_ctx = state;
9993 : }
9994 :
9995 0 : status = dcerpc_clusapi_DeleteGroup_r_recv(subreq, mem_ctx);
9996 0 : TALLOC_FREE(subreq);
9997 0 : if (tevent_req_nterror(req, status)) {
9998 0 : return;
9999 : }
10000 :
10001 : /* Copy out parameters */
10002 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
10003 :
10004 : /* Copy result */
10005 0 : state->orig.out.result = state->tmp.out.result;
10006 :
10007 : /* Reset temporary structure */
10008 0 : NDR_ZERO_STRUCT(state->tmp);
10009 :
10010 0 : tevent_req_done(req);
10011 : }
10012 :
10013 0 : NTSTATUS dcerpc_clusapi_DeleteGroup_recv(struct tevent_req *req,
10014 : TALLOC_CTX *mem_ctx,
10015 : WERROR *result)
10016 : {
10017 0 : struct dcerpc_clusapi_DeleteGroup_state *state = tevent_req_data(
10018 : req, struct dcerpc_clusapi_DeleteGroup_state);
10019 : NTSTATUS status;
10020 :
10021 0 : if (tevent_req_is_nterror(req, &status)) {
10022 0 : tevent_req_received(req);
10023 0 : return status;
10024 : }
10025 :
10026 : /* Steal possible out parameters to the callers context */
10027 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10028 :
10029 : /* Return result */
10030 0 : *result = state->orig.out.result;
10031 :
10032 0 : tevent_req_received(req);
10033 0 : return NT_STATUS_OK;
10034 : }
10035 :
10036 0 : NTSTATUS dcerpc_clusapi_DeleteGroup(struct dcerpc_binding_handle *h,
10037 : TALLOC_CTX *mem_ctx,
10038 : struct policy_handle _Group /* [in] */,
10039 : uint8_t _force /* [in] */,
10040 : WERROR *_rpc_status /* [out] [ref] */,
10041 : WERROR *result)
10042 : {
10043 : struct clusapi_DeleteGroup r;
10044 : NTSTATUS status;
10045 :
10046 : /* In parameters */
10047 0 : r.in.Group = _Group;
10048 0 : r.in.force = _force;
10049 :
10050 : /* Out parameters */
10051 0 : r.out.rpc_status = _rpc_status;
10052 :
10053 : /* Result */
10054 0 : NDR_ZERO_STRUCT(r.out.result);
10055 :
10056 0 : status = dcerpc_clusapi_DeleteGroup_r(h, mem_ctx, &r);
10057 0 : if (!NT_STATUS_IS_OK(status)) {
10058 0 : return status;
10059 : }
10060 :
10061 : /* Return variables */
10062 0 : *_rpc_status = *r.out.rpc_status;
10063 :
10064 : /* Return result */
10065 0 : *result = r.out.result;
10066 :
10067 0 : return NT_STATUS_OK;
10068 : }
10069 :
10070 : struct dcerpc_clusapi_CloseGroup_r_state {
10071 : TALLOC_CTX *out_mem_ctx;
10072 : };
10073 :
10074 : static void dcerpc_clusapi_CloseGroup_r_done(struct tevent_req *subreq);
10075 :
10076 0 : struct tevent_req *dcerpc_clusapi_CloseGroup_r_send(TALLOC_CTX *mem_ctx,
10077 : struct tevent_context *ev,
10078 : struct dcerpc_binding_handle *h,
10079 : struct clusapi_CloseGroup *r)
10080 : {
10081 : struct tevent_req *req;
10082 : struct dcerpc_clusapi_CloseGroup_r_state *state;
10083 : struct tevent_req *subreq;
10084 :
10085 0 : req = tevent_req_create(mem_ctx, &state,
10086 : struct dcerpc_clusapi_CloseGroup_r_state);
10087 0 : if (req == NULL) {
10088 0 : return NULL;
10089 : }
10090 :
10091 0 : state->out_mem_ctx = talloc_new(state);
10092 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10093 0 : return tevent_req_post(req, ev);
10094 : }
10095 :
10096 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
10097 : NULL, &ndr_table_clusapi,
10098 0 : NDR_CLUSAPI_CLOSEGROUP, state->out_mem_ctx, r);
10099 0 : if (tevent_req_nomem(subreq, req)) {
10100 0 : return tevent_req_post(req, ev);
10101 : }
10102 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseGroup_r_done, req);
10103 :
10104 0 : return req;
10105 : }
10106 :
10107 0 : static void dcerpc_clusapi_CloseGroup_r_done(struct tevent_req *subreq)
10108 : {
10109 0 : struct tevent_req *req =
10110 0 : tevent_req_callback_data(subreq,
10111 : struct tevent_req);
10112 : NTSTATUS status;
10113 :
10114 0 : status = dcerpc_binding_handle_call_recv(subreq);
10115 0 : TALLOC_FREE(subreq);
10116 0 : if (tevent_req_nterror(req, status)) {
10117 0 : return;
10118 : }
10119 :
10120 0 : tevent_req_done(req);
10121 : }
10122 :
10123 0 : NTSTATUS dcerpc_clusapi_CloseGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
10124 : {
10125 0 : struct dcerpc_clusapi_CloseGroup_r_state *state =
10126 0 : tevent_req_data(req,
10127 : struct dcerpc_clusapi_CloseGroup_r_state);
10128 : NTSTATUS status;
10129 :
10130 0 : if (tevent_req_is_nterror(req, &status)) {
10131 0 : tevent_req_received(req);
10132 0 : return status;
10133 : }
10134 :
10135 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10136 :
10137 0 : tevent_req_received(req);
10138 0 : return NT_STATUS_OK;
10139 : }
10140 :
10141 0 : NTSTATUS dcerpc_clusapi_CloseGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseGroup *r)
10142 : {
10143 : NTSTATUS status;
10144 :
10145 0 : status = dcerpc_binding_handle_call(h,
10146 : NULL, &ndr_table_clusapi,
10147 : NDR_CLUSAPI_CLOSEGROUP, mem_ctx, r);
10148 :
10149 0 : return status;
10150 : }
10151 :
10152 : struct dcerpc_clusapi_CloseGroup_state {
10153 : struct clusapi_CloseGroup orig;
10154 : struct clusapi_CloseGroup tmp;
10155 : TALLOC_CTX *out_mem_ctx;
10156 : };
10157 :
10158 : static void dcerpc_clusapi_CloseGroup_done(struct tevent_req *subreq);
10159 :
10160 0 : struct tevent_req *dcerpc_clusapi_CloseGroup_send(TALLOC_CTX *mem_ctx,
10161 : struct tevent_context *ev,
10162 : struct dcerpc_binding_handle *h,
10163 : struct policy_handle *_Group /* [in,out] [ref] */)
10164 : {
10165 : struct tevent_req *req;
10166 : struct dcerpc_clusapi_CloseGroup_state *state;
10167 : struct tevent_req *subreq;
10168 :
10169 0 : req = tevent_req_create(mem_ctx, &state,
10170 : struct dcerpc_clusapi_CloseGroup_state);
10171 0 : if (req == NULL) {
10172 0 : return NULL;
10173 : }
10174 0 : state->out_mem_ctx = NULL;
10175 :
10176 : /* In parameters */
10177 0 : state->orig.in.Group = _Group;
10178 :
10179 : /* Out parameters */
10180 0 : state->orig.out.Group = _Group;
10181 :
10182 : /* Result */
10183 0 : NDR_ZERO_STRUCT(state->orig.out.result);
10184 :
10185 0 : state->out_mem_ctx = talloc_named_const(state, 0,
10186 : "dcerpc_clusapi_CloseGroup_out_memory");
10187 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10188 0 : return tevent_req_post(req, ev);
10189 : }
10190 :
10191 : /* make a temporary copy, that we pass to the dispatch function */
10192 0 : state->tmp = state->orig;
10193 :
10194 0 : subreq = dcerpc_clusapi_CloseGroup_r_send(state, ev, h, &state->tmp);
10195 0 : if (tevent_req_nomem(subreq, req)) {
10196 0 : return tevent_req_post(req, ev);
10197 : }
10198 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseGroup_done, req);
10199 0 : return req;
10200 : }
10201 :
10202 0 : static void dcerpc_clusapi_CloseGroup_done(struct tevent_req *subreq)
10203 : {
10204 0 : struct tevent_req *req = tevent_req_callback_data(
10205 : subreq, struct tevent_req);
10206 0 : struct dcerpc_clusapi_CloseGroup_state *state = tevent_req_data(
10207 : req, struct dcerpc_clusapi_CloseGroup_state);
10208 : NTSTATUS status;
10209 : TALLOC_CTX *mem_ctx;
10210 :
10211 0 : if (state->out_mem_ctx) {
10212 0 : mem_ctx = state->out_mem_ctx;
10213 : } else {
10214 0 : mem_ctx = state;
10215 : }
10216 :
10217 0 : status = dcerpc_clusapi_CloseGroup_r_recv(subreq, mem_ctx);
10218 0 : TALLOC_FREE(subreq);
10219 0 : if (tevent_req_nterror(req, status)) {
10220 0 : return;
10221 : }
10222 :
10223 : /* Copy out parameters */
10224 0 : *state->orig.out.Group = *state->tmp.out.Group;
10225 :
10226 : /* Copy result */
10227 0 : state->orig.out.result = state->tmp.out.result;
10228 :
10229 : /* Reset temporary structure */
10230 0 : NDR_ZERO_STRUCT(state->tmp);
10231 :
10232 0 : tevent_req_done(req);
10233 : }
10234 :
10235 0 : NTSTATUS dcerpc_clusapi_CloseGroup_recv(struct tevent_req *req,
10236 : TALLOC_CTX *mem_ctx,
10237 : WERROR *result)
10238 : {
10239 0 : struct dcerpc_clusapi_CloseGroup_state *state = tevent_req_data(
10240 : req, struct dcerpc_clusapi_CloseGroup_state);
10241 : NTSTATUS status;
10242 :
10243 0 : if (tevent_req_is_nterror(req, &status)) {
10244 0 : tevent_req_received(req);
10245 0 : return status;
10246 : }
10247 :
10248 : /* Steal possible out parameters to the callers context */
10249 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10250 :
10251 : /* Return result */
10252 0 : *result = state->orig.out.result;
10253 :
10254 0 : tevent_req_received(req);
10255 0 : return NT_STATUS_OK;
10256 : }
10257 :
10258 0 : NTSTATUS dcerpc_clusapi_CloseGroup(struct dcerpc_binding_handle *h,
10259 : TALLOC_CTX *mem_ctx,
10260 : struct policy_handle *_Group /* [in,out] [ref] */,
10261 : WERROR *result)
10262 : {
10263 : struct clusapi_CloseGroup r;
10264 : NTSTATUS status;
10265 :
10266 : /* In parameters */
10267 0 : r.in.Group = _Group;
10268 :
10269 : /* Out parameters */
10270 0 : r.out.Group = _Group;
10271 :
10272 : /* Result */
10273 0 : NDR_ZERO_STRUCT(r.out.result);
10274 :
10275 0 : status = dcerpc_clusapi_CloseGroup_r(h, mem_ctx, &r);
10276 0 : if (!NT_STATUS_IS_OK(status)) {
10277 0 : return status;
10278 : }
10279 :
10280 : /* Return variables */
10281 0 : *_Group = *r.out.Group;
10282 :
10283 : /* Return result */
10284 0 : *result = r.out.result;
10285 :
10286 0 : return NT_STATUS_OK;
10287 : }
10288 :
10289 : struct dcerpc_clusapi_GetGroupState_r_state {
10290 : TALLOC_CTX *out_mem_ctx;
10291 : };
10292 :
10293 : static void dcerpc_clusapi_GetGroupState_r_done(struct tevent_req *subreq);
10294 :
10295 0 : struct tevent_req *dcerpc_clusapi_GetGroupState_r_send(TALLOC_CTX *mem_ctx,
10296 : struct tevent_context *ev,
10297 : struct dcerpc_binding_handle *h,
10298 : struct clusapi_GetGroupState *r)
10299 : {
10300 : struct tevent_req *req;
10301 : struct dcerpc_clusapi_GetGroupState_r_state *state;
10302 : struct tevent_req *subreq;
10303 :
10304 0 : req = tevent_req_create(mem_ctx, &state,
10305 : struct dcerpc_clusapi_GetGroupState_r_state);
10306 0 : if (req == NULL) {
10307 0 : return NULL;
10308 : }
10309 :
10310 0 : state->out_mem_ctx = talloc_new(state);
10311 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10312 0 : return tevent_req_post(req, ev);
10313 : }
10314 :
10315 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
10316 : NULL, &ndr_table_clusapi,
10317 0 : NDR_CLUSAPI_GETGROUPSTATE, state->out_mem_ctx, r);
10318 0 : if (tevent_req_nomem(subreq, req)) {
10319 0 : return tevent_req_post(req, ev);
10320 : }
10321 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetGroupState_r_done, req);
10322 :
10323 0 : return req;
10324 : }
10325 :
10326 0 : static void dcerpc_clusapi_GetGroupState_r_done(struct tevent_req *subreq)
10327 : {
10328 0 : struct tevent_req *req =
10329 0 : tevent_req_callback_data(subreq,
10330 : struct tevent_req);
10331 : NTSTATUS status;
10332 :
10333 0 : status = dcerpc_binding_handle_call_recv(subreq);
10334 0 : TALLOC_FREE(subreq);
10335 0 : if (tevent_req_nterror(req, status)) {
10336 0 : return;
10337 : }
10338 :
10339 0 : tevent_req_done(req);
10340 : }
10341 :
10342 0 : NTSTATUS dcerpc_clusapi_GetGroupState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
10343 : {
10344 0 : struct dcerpc_clusapi_GetGroupState_r_state *state =
10345 0 : tevent_req_data(req,
10346 : struct dcerpc_clusapi_GetGroupState_r_state);
10347 : NTSTATUS status;
10348 :
10349 0 : if (tevent_req_is_nterror(req, &status)) {
10350 0 : tevent_req_received(req);
10351 0 : return status;
10352 : }
10353 :
10354 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10355 :
10356 0 : tevent_req_received(req);
10357 0 : return NT_STATUS_OK;
10358 : }
10359 :
10360 0 : NTSTATUS dcerpc_clusapi_GetGroupState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetGroupState *r)
10361 : {
10362 : NTSTATUS status;
10363 :
10364 0 : status = dcerpc_binding_handle_call(h,
10365 : NULL, &ndr_table_clusapi,
10366 : NDR_CLUSAPI_GETGROUPSTATE, mem_ctx, r);
10367 :
10368 0 : return status;
10369 : }
10370 :
10371 : struct dcerpc_clusapi_GetGroupState_state {
10372 : struct clusapi_GetGroupState orig;
10373 : struct clusapi_GetGroupState tmp;
10374 : TALLOC_CTX *out_mem_ctx;
10375 : };
10376 :
10377 : static void dcerpc_clusapi_GetGroupState_done(struct tevent_req *subreq);
10378 :
10379 0 : struct tevent_req *dcerpc_clusapi_GetGroupState_send(TALLOC_CTX *mem_ctx,
10380 : struct tevent_context *ev,
10381 : struct dcerpc_binding_handle *h,
10382 : struct policy_handle _hGroup /* [in] */,
10383 : enum clusapi_ClusterGroupState *_State /* [out] [ref] */,
10384 : const char **_NodeName /* [out] [charset(UTF16),ref] */,
10385 : WERROR *_rpc_status /* [out] [ref] */)
10386 : {
10387 : struct tevent_req *req;
10388 : struct dcerpc_clusapi_GetGroupState_state *state;
10389 : struct tevent_req *subreq;
10390 :
10391 0 : req = tevent_req_create(mem_ctx, &state,
10392 : struct dcerpc_clusapi_GetGroupState_state);
10393 0 : if (req == NULL) {
10394 0 : return NULL;
10395 : }
10396 0 : state->out_mem_ctx = NULL;
10397 :
10398 : /* In parameters */
10399 0 : state->orig.in.hGroup = _hGroup;
10400 :
10401 : /* Out parameters */
10402 0 : state->orig.out.State = _State;
10403 0 : state->orig.out.NodeName = _NodeName;
10404 0 : state->orig.out.rpc_status = _rpc_status;
10405 :
10406 : /* Result */
10407 0 : NDR_ZERO_STRUCT(state->orig.out.result);
10408 :
10409 0 : state->out_mem_ctx = talloc_named_const(state, 0,
10410 : "dcerpc_clusapi_GetGroupState_out_memory");
10411 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10412 0 : return tevent_req_post(req, ev);
10413 : }
10414 :
10415 : /* make a temporary copy, that we pass to the dispatch function */
10416 0 : state->tmp = state->orig;
10417 :
10418 0 : subreq = dcerpc_clusapi_GetGroupState_r_send(state, ev, h, &state->tmp);
10419 0 : if (tevent_req_nomem(subreq, req)) {
10420 0 : return tevent_req_post(req, ev);
10421 : }
10422 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetGroupState_done, req);
10423 0 : return req;
10424 : }
10425 :
10426 0 : static void dcerpc_clusapi_GetGroupState_done(struct tevent_req *subreq)
10427 : {
10428 0 : struct tevent_req *req = tevent_req_callback_data(
10429 : subreq, struct tevent_req);
10430 0 : struct dcerpc_clusapi_GetGroupState_state *state = tevent_req_data(
10431 : req, struct dcerpc_clusapi_GetGroupState_state);
10432 : NTSTATUS status;
10433 : TALLOC_CTX *mem_ctx;
10434 :
10435 0 : if (state->out_mem_ctx) {
10436 0 : mem_ctx = state->out_mem_ctx;
10437 : } else {
10438 0 : mem_ctx = state;
10439 : }
10440 :
10441 0 : status = dcerpc_clusapi_GetGroupState_r_recv(subreq, mem_ctx);
10442 0 : TALLOC_FREE(subreq);
10443 0 : if (tevent_req_nterror(req, status)) {
10444 0 : return;
10445 : }
10446 :
10447 : /* Copy out parameters */
10448 0 : *state->orig.out.State = *state->tmp.out.State;
10449 0 : *state->orig.out.NodeName = *state->tmp.out.NodeName;
10450 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
10451 :
10452 : /* Copy result */
10453 0 : state->orig.out.result = state->tmp.out.result;
10454 :
10455 : /* Reset temporary structure */
10456 0 : NDR_ZERO_STRUCT(state->tmp);
10457 :
10458 0 : tevent_req_done(req);
10459 : }
10460 :
10461 0 : NTSTATUS dcerpc_clusapi_GetGroupState_recv(struct tevent_req *req,
10462 : TALLOC_CTX *mem_ctx,
10463 : WERROR *result)
10464 : {
10465 0 : struct dcerpc_clusapi_GetGroupState_state *state = tevent_req_data(
10466 : req, struct dcerpc_clusapi_GetGroupState_state);
10467 : NTSTATUS status;
10468 :
10469 0 : if (tevent_req_is_nterror(req, &status)) {
10470 0 : tevent_req_received(req);
10471 0 : return status;
10472 : }
10473 :
10474 : /* Steal possible out parameters to the callers context */
10475 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10476 :
10477 : /* Return result */
10478 0 : *result = state->orig.out.result;
10479 :
10480 0 : tevent_req_received(req);
10481 0 : return NT_STATUS_OK;
10482 : }
10483 :
10484 0 : NTSTATUS dcerpc_clusapi_GetGroupState(struct dcerpc_binding_handle *h,
10485 : TALLOC_CTX *mem_ctx,
10486 : struct policy_handle _hGroup /* [in] */,
10487 : enum clusapi_ClusterGroupState *_State /* [out] [ref] */,
10488 : const char **_NodeName /* [out] [charset(UTF16),ref] */,
10489 : WERROR *_rpc_status /* [out] [ref] */,
10490 : WERROR *result)
10491 : {
10492 : struct clusapi_GetGroupState r;
10493 : NTSTATUS status;
10494 :
10495 : /* In parameters */
10496 0 : r.in.hGroup = _hGroup;
10497 :
10498 : /* Out parameters */
10499 0 : r.out.State = _State;
10500 0 : r.out.NodeName = _NodeName;
10501 0 : r.out.rpc_status = _rpc_status;
10502 :
10503 : /* Result */
10504 0 : NDR_ZERO_STRUCT(r.out.result);
10505 :
10506 0 : status = dcerpc_clusapi_GetGroupState_r(h, mem_ctx, &r);
10507 0 : if (!NT_STATUS_IS_OK(status)) {
10508 0 : return status;
10509 : }
10510 :
10511 : /* Return variables */
10512 0 : *_State = *r.out.State;
10513 0 : *_NodeName = *r.out.NodeName;
10514 0 : *_rpc_status = *r.out.rpc_status;
10515 :
10516 : /* Return result */
10517 0 : *result = r.out.result;
10518 :
10519 0 : return NT_STATUS_OK;
10520 : }
10521 :
10522 : struct dcerpc_clusapi_SetGroupName_r_state {
10523 : TALLOC_CTX *out_mem_ctx;
10524 : };
10525 :
10526 : static void dcerpc_clusapi_SetGroupName_r_done(struct tevent_req *subreq);
10527 :
10528 0 : struct tevent_req *dcerpc_clusapi_SetGroupName_r_send(TALLOC_CTX *mem_ctx,
10529 : struct tevent_context *ev,
10530 : struct dcerpc_binding_handle *h,
10531 : struct clusapi_SetGroupName *r)
10532 : {
10533 : struct tevent_req *req;
10534 : struct dcerpc_clusapi_SetGroupName_r_state *state;
10535 : struct tevent_req *subreq;
10536 :
10537 0 : req = tevent_req_create(mem_ctx, &state,
10538 : struct dcerpc_clusapi_SetGroupName_r_state);
10539 0 : if (req == NULL) {
10540 0 : return NULL;
10541 : }
10542 :
10543 0 : state->out_mem_ctx = talloc_new(state);
10544 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10545 0 : return tevent_req_post(req, ev);
10546 : }
10547 :
10548 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
10549 : NULL, &ndr_table_clusapi,
10550 0 : NDR_CLUSAPI_SETGROUPNAME, state->out_mem_ctx, r);
10551 0 : if (tevent_req_nomem(subreq, req)) {
10552 0 : return tevent_req_post(req, ev);
10553 : }
10554 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupName_r_done, req);
10555 :
10556 0 : return req;
10557 : }
10558 :
10559 0 : static void dcerpc_clusapi_SetGroupName_r_done(struct tevent_req *subreq)
10560 : {
10561 0 : struct tevent_req *req =
10562 0 : tevent_req_callback_data(subreq,
10563 : struct tevent_req);
10564 : NTSTATUS status;
10565 :
10566 0 : status = dcerpc_binding_handle_call_recv(subreq);
10567 0 : TALLOC_FREE(subreq);
10568 0 : if (tevent_req_nterror(req, status)) {
10569 0 : return;
10570 : }
10571 :
10572 0 : tevent_req_done(req);
10573 : }
10574 :
10575 0 : NTSTATUS dcerpc_clusapi_SetGroupName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
10576 : {
10577 0 : struct dcerpc_clusapi_SetGroupName_r_state *state =
10578 0 : tevent_req_data(req,
10579 : struct dcerpc_clusapi_SetGroupName_r_state);
10580 : NTSTATUS status;
10581 :
10582 0 : if (tevent_req_is_nterror(req, &status)) {
10583 0 : tevent_req_received(req);
10584 0 : return status;
10585 : }
10586 :
10587 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10588 :
10589 0 : tevent_req_received(req);
10590 0 : return NT_STATUS_OK;
10591 : }
10592 :
10593 0 : NTSTATUS dcerpc_clusapi_SetGroupName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetGroupName *r)
10594 : {
10595 : NTSTATUS status;
10596 :
10597 0 : status = dcerpc_binding_handle_call(h,
10598 : NULL, &ndr_table_clusapi,
10599 : NDR_CLUSAPI_SETGROUPNAME, mem_ctx, r);
10600 :
10601 0 : return status;
10602 : }
10603 :
10604 : struct dcerpc_clusapi_SetGroupName_state {
10605 : struct clusapi_SetGroupName orig;
10606 : struct clusapi_SetGroupName tmp;
10607 : TALLOC_CTX *out_mem_ctx;
10608 : };
10609 :
10610 : static void dcerpc_clusapi_SetGroupName_done(struct tevent_req *subreq);
10611 :
10612 0 : struct tevent_req *dcerpc_clusapi_SetGroupName_send(TALLOC_CTX *mem_ctx,
10613 : struct tevent_context *ev,
10614 : struct dcerpc_binding_handle *h,
10615 : struct policy_handle _hGroup /* [in] */,
10616 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
10617 : WERROR *_rpc_status /* [out] [ref] */)
10618 : {
10619 : struct tevent_req *req;
10620 : struct dcerpc_clusapi_SetGroupName_state *state;
10621 : struct tevent_req *subreq;
10622 :
10623 0 : req = tevent_req_create(mem_ctx, &state,
10624 : struct dcerpc_clusapi_SetGroupName_state);
10625 0 : if (req == NULL) {
10626 0 : return NULL;
10627 : }
10628 0 : state->out_mem_ctx = NULL;
10629 :
10630 : /* In parameters */
10631 0 : state->orig.in.hGroup = _hGroup;
10632 0 : state->orig.in.lpszGroupName = _lpszGroupName;
10633 :
10634 : /* Out parameters */
10635 0 : state->orig.out.rpc_status = _rpc_status;
10636 :
10637 : /* Result */
10638 0 : NDR_ZERO_STRUCT(state->orig.out.result);
10639 :
10640 0 : state->out_mem_ctx = talloc_named_const(state, 0,
10641 : "dcerpc_clusapi_SetGroupName_out_memory");
10642 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10643 0 : return tevent_req_post(req, ev);
10644 : }
10645 :
10646 : /* make a temporary copy, that we pass to the dispatch function */
10647 0 : state->tmp = state->orig;
10648 :
10649 0 : subreq = dcerpc_clusapi_SetGroupName_r_send(state, ev, h, &state->tmp);
10650 0 : if (tevent_req_nomem(subreq, req)) {
10651 0 : return tevent_req_post(req, ev);
10652 : }
10653 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupName_done, req);
10654 0 : return req;
10655 : }
10656 :
10657 0 : static void dcerpc_clusapi_SetGroupName_done(struct tevent_req *subreq)
10658 : {
10659 0 : struct tevent_req *req = tevent_req_callback_data(
10660 : subreq, struct tevent_req);
10661 0 : struct dcerpc_clusapi_SetGroupName_state *state = tevent_req_data(
10662 : req, struct dcerpc_clusapi_SetGroupName_state);
10663 : NTSTATUS status;
10664 : TALLOC_CTX *mem_ctx;
10665 :
10666 0 : if (state->out_mem_ctx) {
10667 0 : mem_ctx = state->out_mem_ctx;
10668 : } else {
10669 0 : mem_ctx = state;
10670 : }
10671 :
10672 0 : status = dcerpc_clusapi_SetGroupName_r_recv(subreq, mem_ctx);
10673 0 : TALLOC_FREE(subreq);
10674 0 : if (tevent_req_nterror(req, status)) {
10675 0 : return;
10676 : }
10677 :
10678 : /* Copy out parameters */
10679 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
10680 :
10681 : /* Copy result */
10682 0 : state->orig.out.result = state->tmp.out.result;
10683 :
10684 : /* Reset temporary structure */
10685 0 : NDR_ZERO_STRUCT(state->tmp);
10686 :
10687 0 : tevent_req_done(req);
10688 : }
10689 :
10690 0 : NTSTATUS dcerpc_clusapi_SetGroupName_recv(struct tevent_req *req,
10691 : TALLOC_CTX *mem_ctx,
10692 : WERROR *result)
10693 : {
10694 0 : struct dcerpc_clusapi_SetGroupName_state *state = tevent_req_data(
10695 : req, struct dcerpc_clusapi_SetGroupName_state);
10696 : NTSTATUS status;
10697 :
10698 0 : if (tevent_req_is_nterror(req, &status)) {
10699 0 : tevent_req_received(req);
10700 0 : return status;
10701 : }
10702 :
10703 : /* Steal possible out parameters to the callers context */
10704 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10705 :
10706 : /* Return result */
10707 0 : *result = state->orig.out.result;
10708 :
10709 0 : tevent_req_received(req);
10710 0 : return NT_STATUS_OK;
10711 : }
10712 :
10713 0 : NTSTATUS dcerpc_clusapi_SetGroupName(struct dcerpc_binding_handle *h,
10714 : TALLOC_CTX *mem_ctx,
10715 : struct policy_handle _hGroup /* [in] */,
10716 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
10717 : WERROR *_rpc_status /* [out] [ref] */,
10718 : WERROR *result)
10719 : {
10720 : struct clusapi_SetGroupName r;
10721 : NTSTATUS status;
10722 :
10723 : /* In parameters */
10724 0 : r.in.hGroup = _hGroup;
10725 0 : r.in.lpszGroupName = _lpszGroupName;
10726 :
10727 : /* Out parameters */
10728 0 : r.out.rpc_status = _rpc_status;
10729 :
10730 : /* Result */
10731 0 : NDR_ZERO_STRUCT(r.out.result);
10732 :
10733 0 : status = dcerpc_clusapi_SetGroupName_r(h, mem_ctx, &r);
10734 0 : if (!NT_STATUS_IS_OK(status)) {
10735 0 : return status;
10736 : }
10737 :
10738 : /* Return variables */
10739 0 : *_rpc_status = *r.out.rpc_status;
10740 :
10741 : /* Return result */
10742 0 : *result = r.out.result;
10743 :
10744 0 : return NT_STATUS_OK;
10745 : }
10746 :
10747 : struct dcerpc_clusapi_GetGroupId_r_state {
10748 : TALLOC_CTX *out_mem_ctx;
10749 : };
10750 :
10751 : static void dcerpc_clusapi_GetGroupId_r_done(struct tevent_req *subreq);
10752 :
10753 0 : struct tevent_req *dcerpc_clusapi_GetGroupId_r_send(TALLOC_CTX *mem_ctx,
10754 : struct tevent_context *ev,
10755 : struct dcerpc_binding_handle *h,
10756 : struct clusapi_GetGroupId *r)
10757 : {
10758 : struct tevent_req *req;
10759 : struct dcerpc_clusapi_GetGroupId_r_state *state;
10760 : struct tevent_req *subreq;
10761 :
10762 0 : req = tevent_req_create(mem_ctx, &state,
10763 : struct dcerpc_clusapi_GetGroupId_r_state);
10764 0 : if (req == NULL) {
10765 0 : return NULL;
10766 : }
10767 :
10768 0 : state->out_mem_ctx = talloc_new(state);
10769 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10770 0 : return tevent_req_post(req, ev);
10771 : }
10772 :
10773 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
10774 : NULL, &ndr_table_clusapi,
10775 0 : NDR_CLUSAPI_GETGROUPID, state->out_mem_ctx, r);
10776 0 : if (tevent_req_nomem(subreq, req)) {
10777 0 : return tevent_req_post(req, ev);
10778 : }
10779 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetGroupId_r_done, req);
10780 :
10781 0 : return req;
10782 : }
10783 :
10784 0 : static void dcerpc_clusapi_GetGroupId_r_done(struct tevent_req *subreq)
10785 : {
10786 0 : struct tevent_req *req =
10787 0 : tevent_req_callback_data(subreq,
10788 : struct tevent_req);
10789 : NTSTATUS status;
10790 :
10791 0 : status = dcerpc_binding_handle_call_recv(subreq);
10792 0 : TALLOC_FREE(subreq);
10793 0 : if (tevent_req_nterror(req, status)) {
10794 0 : return;
10795 : }
10796 :
10797 0 : tevent_req_done(req);
10798 : }
10799 :
10800 0 : NTSTATUS dcerpc_clusapi_GetGroupId_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
10801 : {
10802 0 : struct dcerpc_clusapi_GetGroupId_r_state *state =
10803 0 : tevent_req_data(req,
10804 : struct dcerpc_clusapi_GetGroupId_r_state);
10805 : NTSTATUS status;
10806 :
10807 0 : if (tevent_req_is_nterror(req, &status)) {
10808 0 : tevent_req_received(req);
10809 0 : return status;
10810 : }
10811 :
10812 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10813 :
10814 0 : tevent_req_received(req);
10815 0 : return NT_STATUS_OK;
10816 : }
10817 :
10818 0 : NTSTATUS dcerpc_clusapi_GetGroupId_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetGroupId *r)
10819 : {
10820 : NTSTATUS status;
10821 :
10822 0 : status = dcerpc_binding_handle_call(h,
10823 : NULL, &ndr_table_clusapi,
10824 : NDR_CLUSAPI_GETGROUPID, mem_ctx, r);
10825 :
10826 0 : return status;
10827 : }
10828 :
10829 : struct dcerpc_clusapi_GetGroupId_state {
10830 : struct clusapi_GetGroupId orig;
10831 : struct clusapi_GetGroupId tmp;
10832 : TALLOC_CTX *out_mem_ctx;
10833 : };
10834 :
10835 : static void dcerpc_clusapi_GetGroupId_done(struct tevent_req *subreq);
10836 :
10837 0 : struct tevent_req *dcerpc_clusapi_GetGroupId_send(TALLOC_CTX *mem_ctx,
10838 : struct tevent_context *ev,
10839 : struct dcerpc_binding_handle *h,
10840 : struct policy_handle _hGroup /* [in] */,
10841 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
10842 : WERROR *_rpc_status /* [out] [ref] */)
10843 : {
10844 : struct tevent_req *req;
10845 : struct dcerpc_clusapi_GetGroupId_state *state;
10846 : struct tevent_req *subreq;
10847 :
10848 0 : req = tevent_req_create(mem_ctx, &state,
10849 : struct dcerpc_clusapi_GetGroupId_state);
10850 0 : if (req == NULL) {
10851 0 : return NULL;
10852 : }
10853 0 : state->out_mem_ctx = NULL;
10854 :
10855 : /* In parameters */
10856 0 : state->orig.in.hGroup = _hGroup;
10857 :
10858 : /* Out parameters */
10859 0 : state->orig.out.pGuid = _pGuid;
10860 0 : state->orig.out.rpc_status = _rpc_status;
10861 :
10862 : /* Result */
10863 0 : NDR_ZERO_STRUCT(state->orig.out.result);
10864 :
10865 0 : state->out_mem_ctx = talloc_named_const(state, 0,
10866 : "dcerpc_clusapi_GetGroupId_out_memory");
10867 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10868 0 : return tevent_req_post(req, ev);
10869 : }
10870 :
10871 : /* make a temporary copy, that we pass to the dispatch function */
10872 0 : state->tmp = state->orig;
10873 :
10874 0 : subreq = dcerpc_clusapi_GetGroupId_r_send(state, ev, h, &state->tmp);
10875 0 : if (tevent_req_nomem(subreq, req)) {
10876 0 : return tevent_req_post(req, ev);
10877 : }
10878 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetGroupId_done, req);
10879 0 : return req;
10880 : }
10881 :
10882 0 : static void dcerpc_clusapi_GetGroupId_done(struct tevent_req *subreq)
10883 : {
10884 0 : struct tevent_req *req = tevent_req_callback_data(
10885 : subreq, struct tevent_req);
10886 0 : struct dcerpc_clusapi_GetGroupId_state *state = tevent_req_data(
10887 : req, struct dcerpc_clusapi_GetGroupId_state);
10888 : NTSTATUS status;
10889 : TALLOC_CTX *mem_ctx;
10890 :
10891 0 : if (state->out_mem_ctx) {
10892 0 : mem_ctx = state->out_mem_ctx;
10893 : } else {
10894 0 : mem_ctx = state;
10895 : }
10896 :
10897 0 : status = dcerpc_clusapi_GetGroupId_r_recv(subreq, mem_ctx);
10898 0 : TALLOC_FREE(subreq);
10899 0 : if (tevent_req_nterror(req, status)) {
10900 0 : return;
10901 : }
10902 :
10903 : /* Copy out parameters */
10904 0 : *state->orig.out.pGuid = *state->tmp.out.pGuid;
10905 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
10906 :
10907 : /* Copy result */
10908 0 : state->orig.out.result = state->tmp.out.result;
10909 :
10910 : /* Reset temporary structure */
10911 0 : NDR_ZERO_STRUCT(state->tmp);
10912 :
10913 0 : tevent_req_done(req);
10914 : }
10915 :
10916 0 : NTSTATUS dcerpc_clusapi_GetGroupId_recv(struct tevent_req *req,
10917 : TALLOC_CTX *mem_ctx,
10918 : WERROR *result)
10919 : {
10920 0 : struct dcerpc_clusapi_GetGroupId_state *state = tevent_req_data(
10921 : req, struct dcerpc_clusapi_GetGroupId_state);
10922 : NTSTATUS status;
10923 :
10924 0 : if (tevent_req_is_nterror(req, &status)) {
10925 0 : tevent_req_received(req);
10926 0 : return status;
10927 : }
10928 :
10929 : /* Steal possible out parameters to the callers context */
10930 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
10931 :
10932 : /* Return result */
10933 0 : *result = state->orig.out.result;
10934 :
10935 0 : tevent_req_received(req);
10936 0 : return NT_STATUS_OK;
10937 : }
10938 :
10939 0 : NTSTATUS dcerpc_clusapi_GetGroupId(struct dcerpc_binding_handle *h,
10940 : TALLOC_CTX *mem_ctx,
10941 : struct policy_handle _hGroup /* [in] */,
10942 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
10943 : WERROR *_rpc_status /* [out] [ref] */,
10944 : WERROR *result)
10945 : {
10946 : struct clusapi_GetGroupId r;
10947 : NTSTATUS status;
10948 :
10949 : /* In parameters */
10950 0 : r.in.hGroup = _hGroup;
10951 :
10952 : /* Out parameters */
10953 0 : r.out.pGuid = _pGuid;
10954 0 : r.out.rpc_status = _rpc_status;
10955 :
10956 : /* Result */
10957 0 : NDR_ZERO_STRUCT(r.out.result);
10958 :
10959 0 : status = dcerpc_clusapi_GetGroupId_r(h, mem_ctx, &r);
10960 0 : if (!NT_STATUS_IS_OK(status)) {
10961 0 : return status;
10962 : }
10963 :
10964 : /* Return variables */
10965 0 : *_pGuid = *r.out.pGuid;
10966 0 : *_rpc_status = *r.out.rpc_status;
10967 :
10968 : /* Return result */
10969 0 : *result = r.out.result;
10970 :
10971 0 : return NT_STATUS_OK;
10972 : }
10973 :
10974 : struct dcerpc_clusapi_GetNodeId_r_state {
10975 : TALLOC_CTX *out_mem_ctx;
10976 : };
10977 :
10978 : static void dcerpc_clusapi_GetNodeId_r_done(struct tevent_req *subreq);
10979 :
10980 0 : struct tevent_req *dcerpc_clusapi_GetNodeId_r_send(TALLOC_CTX *mem_ctx,
10981 : struct tevent_context *ev,
10982 : struct dcerpc_binding_handle *h,
10983 : struct clusapi_GetNodeId *r)
10984 : {
10985 : struct tevent_req *req;
10986 : struct dcerpc_clusapi_GetNodeId_r_state *state;
10987 : struct tevent_req *subreq;
10988 :
10989 0 : req = tevent_req_create(mem_ctx, &state,
10990 : struct dcerpc_clusapi_GetNodeId_r_state);
10991 0 : if (req == NULL) {
10992 0 : return NULL;
10993 : }
10994 :
10995 0 : state->out_mem_ctx = talloc_new(state);
10996 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
10997 0 : return tevent_req_post(req, ev);
10998 : }
10999 :
11000 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
11001 : NULL, &ndr_table_clusapi,
11002 0 : NDR_CLUSAPI_GETNODEID, state->out_mem_ctx, r);
11003 0 : if (tevent_req_nomem(subreq, req)) {
11004 0 : return tevent_req_post(req, ev);
11005 : }
11006 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNodeId_r_done, req);
11007 :
11008 0 : return req;
11009 : }
11010 :
11011 0 : static void dcerpc_clusapi_GetNodeId_r_done(struct tevent_req *subreq)
11012 : {
11013 0 : struct tevent_req *req =
11014 0 : tevent_req_callback_data(subreq,
11015 : struct tevent_req);
11016 : NTSTATUS status;
11017 :
11018 0 : status = dcerpc_binding_handle_call_recv(subreq);
11019 0 : TALLOC_FREE(subreq);
11020 0 : if (tevent_req_nterror(req, status)) {
11021 0 : return;
11022 : }
11023 :
11024 0 : tevent_req_done(req);
11025 : }
11026 :
11027 0 : NTSTATUS dcerpc_clusapi_GetNodeId_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
11028 : {
11029 0 : struct dcerpc_clusapi_GetNodeId_r_state *state =
11030 0 : tevent_req_data(req,
11031 : struct dcerpc_clusapi_GetNodeId_r_state);
11032 : NTSTATUS status;
11033 :
11034 0 : if (tevent_req_is_nterror(req, &status)) {
11035 0 : tevent_req_received(req);
11036 0 : return status;
11037 : }
11038 :
11039 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11040 :
11041 0 : tevent_req_received(req);
11042 0 : return NT_STATUS_OK;
11043 : }
11044 :
11045 0 : NTSTATUS dcerpc_clusapi_GetNodeId_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNodeId *r)
11046 : {
11047 : NTSTATUS status;
11048 :
11049 0 : status = dcerpc_binding_handle_call(h,
11050 : NULL, &ndr_table_clusapi,
11051 : NDR_CLUSAPI_GETNODEID, mem_ctx, r);
11052 :
11053 0 : return status;
11054 : }
11055 :
11056 : struct dcerpc_clusapi_GetNodeId_state {
11057 : struct clusapi_GetNodeId orig;
11058 : struct clusapi_GetNodeId tmp;
11059 : TALLOC_CTX *out_mem_ctx;
11060 : };
11061 :
11062 : static void dcerpc_clusapi_GetNodeId_done(struct tevent_req *subreq);
11063 :
11064 0 : struct tevent_req *dcerpc_clusapi_GetNodeId_send(TALLOC_CTX *mem_ctx,
11065 : struct tevent_context *ev,
11066 : struct dcerpc_binding_handle *h,
11067 : struct policy_handle _hNode /* [in] */,
11068 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
11069 : WERROR *_rpc_status /* [out] [ref] */)
11070 : {
11071 : struct tevent_req *req;
11072 : struct dcerpc_clusapi_GetNodeId_state *state;
11073 : struct tevent_req *subreq;
11074 :
11075 0 : req = tevent_req_create(mem_ctx, &state,
11076 : struct dcerpc_clusapi_GetNodeId_state);
11077 0 : if (req == NULL) {
11078 0 : return NULL;
11079 : }
11080 0 : state->out_mem_ctx = NULL;
11081 :
11082 : /* In parameters */
11083 0 : state->orig.in.hNode = _hNode;
11084 :
11085 : /* Out parameters */
11086 0 : state->orig.out.pGuid = _pGuid;
11087 0 : state->orig.out.rpc_status = _rpc_status;
11088 :
11089 : /* Result */
11090 0 : NDR_ZERO_STRUCT(state->orig.out.result);
11091 :
11092 0 : state->out_mem_ctx = talloc_named_const(state, 0,
11093 : "dcerpc_clusapi_GetNodeId_out_memory");
11094 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11095 0 : return tevent_req_post(req, ev);
11096 : }
11097 :
11098 : /* make a temporary copy, that we pass to the dispatch function */
11099 0 : state->tmp = state->orig;
11100 :
11101 0 : subreq = dcerpc_clusapi_GetNodeId_r_send(state, ev, h, &state->tmp);
11102 0 : if (tevent_req_nomem(subreq, req)) {
11103 0 : return tevent_req_post(req, ev);
11104 : }
11105 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNodeId_done, req);
11106 0 : return req;
11107 : }
11108 :
11109 0 : static void dcerpc_clusapi_GetNodeId_done(struct tevent_req *subreq)
11110 : {
11111 0 : struct tevent_req *req = tevent_req_callback_data(
11112 : subreq, struct tevent_req);
11113 0 : struct dcerpc_clusapi_GetNodeId_state *state = tevent_req_data(
11114 : req, struct dcerpc_clusapi_GetNodeId_state);
11115 : NTSTATUS status;
11116 : TALLOC_CTX *mem_ctx;
11117 :
11118 0 : if (state->out_mem_ctx) {
11119 0 : mem_ctx = state->out_mem_ctx;
11120 : } else {
11121 0 : mem_ctx = state;
11122 : }
11123 :
11124 0 : status = dcerpc_clusapi_GetNodeId_r_recv(subreq, mem_ctx);
11125 0 : TALLOC_FREE(subreq);
11126 0 : if (tevent_req_nterror(req, status)) {
11127 0 : return;
11128 : }
11129 :
11130 : /* Copy out parameters */
11131 0 : *state->orig.out.pGuid = *state->tmp.out.pGuid;
11132 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
11133 :
11134 : /* Copy result */
11135 0 : state->orig.out.result = state->tmp.out.result;
11136 :
11137 : /* Reset temporary structure */
11138 0 : NDR_ZERO_STRUCT(state->tmp);
11139 :
11140 0 : tevent_req_done(req);
11141 : }
11142 :
11143 0 : NTSTATUS dcerpc_clusapi_GetNodeId_recv(struct tevent_req *req,
11144 : TALLOC_CTX *mem_ctx,
11145 : WERROR *result)
11146 : {
11147 0 : struct dcerpc_clusapi_GetNodeId_state *state = tevent_req_data(
11148 : req, struct dcerpc_clusapi_GetNodeId_state);
11149 : NTSTATUS status;
11150 :
11151 0 : if (tevent_req_is_nterror(req, &status)) {
11152 0 : tevent_req_received(req);
11153 0 : return status;
11154 : }
11155 :
11156 : /* Steal possible out parameters to the callers context */
11157 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11158 :
11159 : /* Return result */
11160 0 : *result = state->orig.out.result;
11161 :
11162 0 : tevent_req_received(req);
11163 0 : return NT_STATUS_OK;
11164 : }
11165 :
11166 0 : NTSTATUS dcerpc_clusapi_GetNodeId(struct dcerpc_binding_handle *h,
11167 : TALLOC_CTX *mem_ctx,
11168 : struct policy_handle _hNode /* [in] */,
11169 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
11170 : WERROR *_rpc_status /* [out] [ref] */,
11171 : WERROR *result)
11172 : {
11173 : struct clusapi_GetNodeId r;
11174 : NTSTATUS status;
11175 :
11176 : /* In parameters */
11177 0 : r.in.hNode = _hNode;
11178 :
11179 : /* Out parameters */
11180 0 : r.out.pGuid = _pGuid;
11181 0 : r.out.rpc_status = _rpc_status;
11182 :
11183 : /* Result */
11184 0 : NDR_ZERO_STRUCT(r.out.result);
11185 :
11186 0 : status = dcerpc_clusapi_GetNodeId_r(h, mem_ctx, &r);
11187 0 : if (!NT_STATUS_IS_OK(status)) {
11188 0 : return status;
11189 : }
11190 :
11191 : /* Return variables */
11192 0 : *_pGuid = *r.out.pGuid;
11193 0 : *_rpc_status = *r.out.rpc_status;
11194 :
11195 : /* Return result */
11196 0 : *result = r.out.result;
11197 :
11198 0 : return NT_STATUS_OK;
11199 : }
11200 :
11201 : struct dcerpc_clusapi_OnlineGroup_r_state {
11202 : TALLOC_CTX *out_mem_ctx;
11203 : };
11204 :
11205 : static void dcerpc_clusapi_OnlineGroup_r_done(struct tevent_req *subreq);
11206 :
11207 0 : struct tevent_req *dcerpc_clusapi_OnlineGroup_r_send(TALLOC_CTX *mem_ctx,
11208 : struct tevent_context *ev,
11209 : struct dcerpc_binding_handle *h,
11210 : struct clusapi_OnlineGroup *r)
11211 : {
11212 : struct tevent_req *req;
11213 : struct dcerpc_clusapi_OnlineGroup_r_state *state;
11214 : struct tevent_req *subreq;
11215 :
11216 0 : req = tevent_req_create(mem_ctx, &state,
11217 : struct dcerpc_clusapi_OnlineGroup_r_state);
11218 0 : if (req == NULL) {
11219 0 : return NULL;
11220 : }
11221 :
11222 0 : state->out_mem_ctx = talloc_new(state);
11223 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11224 0 : return tevent_req_post(req, ev);
11225 : }
11226 :
11227 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
11228 : NULL, &ndr_table_clusapi,
11229 0 : NDR_CLUSAPI_ONLINEGROUP, state->out_mem_ctx, r);
11230 0 : if (tevent_req_nomem(subreq, req)) {
11231 0 : return tevent_req_post(req, ev);
11232 : }
11233 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineGroup_r_done, req);
11234 :
11235 0 : return req;
11236 : }
11237 :
11238 0 : static void dcerpc_clusapi_OnlineGroup_r_done(struct tevent_req *subreq)
11239 : {
11240 0 : struct tevent_req *req =
11241 0 : tevent_req_callback_data(subreq,
11242 : struct tevent_req);
11243 : NTSTATUS status;
11244 :
11245 0 : status = dcerpc_binding_handle_call_recv(subreq);
11246 0 : TALLOC_FREE(subreq);
11247 0 : if (tevent_req_nterror(req, status)) {
11248 0 : return;
11249 : }
11250 :
11251 0 : tevent_req_done(req);
11252 : }
11253 :
11254 0 : NTSTATUS dcerpc_clusapi_OnlineGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
11255 : {
11256 0 : struct dcerpc_clusapi_OnlineGroup_r_state *state =
11257 0 : tevent_req_data(req,
11258 : struct dcerpc_clusapi_OnlineGroup_r_state);
11259 : NTSTATUS status;
11260 :
11261 0 : if (tevent_req_is_nterror(req, &status)) {
11262 0 : tevent_req_received(req);
11263 0 : return status;
11264 : }
11265 :
11266 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11267 :
11268 0 : tevent_req_received(req);
11269 0 : return NT_STATUS_OK;
11270 : }
11271 :
11272 0 : NTSTATUS dcerpc_clusapi_OnlineGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OnlineGroup *r)
11273 : {
11274 : NTSTATUS status;
11275 :
11276 0 : status = dcerpc_binding_handle_call(h,
11277 : NULL, &ndr_table_clusapi,
11278 : NDR_CLUSAPI_ONLINEGROUP, mem_ctx, r);
11279 :
11280 0 : return status;
11281 : }
11282 :
11283 : struct dcerpc_clusapi_OnlineGroup_state {
11284 : struct clusapi_OnlineGroup orig;
11285 : struct clusapi_OnlineGroup tmp;
11286 : TALLOC_CTX *out_mem_ctx;
11287 : };
11288 :
11289 : static void dcerpc_clusapi_OnlineGroup_done(struct tevent_req *subreq);
11290 :
11291 0 : struct tevent_req *dcerpc_clusapi_OnlineGroup_send(TALLOC_CTX *mem_ctx,
11292 : struct tevent_context *ev,
11293 : struct dcerpc_binding_handle *h,
11294 : struct policy_handle _hGroup /* [in] */,
11295 : WERROR *_rpc_status /* [out] [ref] */)
11296 : {
11297 : struct tevent_req *req;
11298 : struct dcerpc_clusapi_OnlineGroup_state *state;
11299 : struct tevent_req *subreq;
11300 :
11301 0 : req = tevent_req_create(mem_ctx, &state,
11302 : struct dcerpc_clusapi_OnlineGroup_state);
11303 0 : if (req == NULL) {
11304 0 : return NULL;
11305 : }
11306 0 : state->out_mem_ctx = NULL;
11307 :
11308 : /* In parameters */
11309 0 : state->orig.in.hGroup = _hGroup;
11310 :
11311 : /* Out parameters */
11312 0 : state->orig.out.rpc_status = _rpc_status;
11313 :
11314 : /* Result */
11315 0 : NDR_ZERO_STRUCT(state->orig.out.result);
11316 :
11317 0 : state->out_mem_ctx = talloc_named_const(state, 0,
11318 : "dcerpc_clusapi_OnlineGroup_out_memory");
11319 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11320 0 : return tevent_req_post(req, ev);
11321 : }
11322 :
11323 : /* make a temporary copy, that we pass to the dispatch function */
11324 0 : state->tmp = state->orig;
11325 :
11326 0 : subreq = dcerpc_clusapi_OnlineGroup_r_send(state, ev, h, &state->tmp);
11327 0 : if (tevent_req_nomem(subreq, req)) {
11328 0 : return tevent_req_post(req, ev);
11329 : }
11330 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineGroup_done, req);
11331 0 : return req;
11332 : }
11333 :
11334 0 : static void dcerpc_clusapi_OnlineGroup_done(struct tevent_req *subreq)
11335 : {
11336 0 : struct tevent_req *req = tevent_req_callback_data(
11337 : subreq, struct tevent_req);
11338 0 : struct dcerpc_clusapi_OnlineGroup_state *state = tevent_req_data(
11339 : req, struct dcerpc_clusapi_OnlineGroup_state);
11340 : NTSTATUS status;
11341 : TALLOC_CTX *mem_ctx;
11342 :
11343 0 : if (state->out_mem_ctx) {
11344 0 : mem_ctx = state->out_mem_ctx;
11345 : } else {
11346 0 : mem_ctx = state;
11347 : }
11348 :
11349 0 : status = dcerpc_clusapi_OnlineGroup_r_recv(subreq, mem_ctx);
11350 0 : TALLOC_FREE(subreq);
11351 0 : if (tevent_req_nterror(req, status)) {
11352 0 : return;
11353 : }
11354 :
11355 : /* Copy out parameters */
11356 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
11357 :
11358 : /* Copy result */
11359 0 : state->orig.out.result = state->tmp.out.result;
11360 :
11361 : /* Reset temporary structure */
11362 0 : NDR_ZERO_STRUCT(state->tmp);
11363 :
11364 0 : tevent_req_done(req);
11365 : }
11366 :
11367 0 : NTSTATUS dcerpc_clusapi_OnlineGroup_recv(struct tevent_req *req,
11368 : TALLOC_CTX *mem_ctx,
11369 : WERROR *result)
11370 : {
11371 0 : struct dcerpc_clusapi_OnlineGroup_state *state = tevent_req_data(
11372 : req, struct dcerpc_clusapi_OnlineGroup_state);
11373 : NTSTATUS status;
11374 :
11375 0 : if (tevent_req_is_nterror(req, &status)) {
11376 0 : tevent_req_received(req);
11377 0 : return status;
11378 : }
11379 :
11380 : /* Steal possible out parameters to the callers context */
11381 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11382 :
11383 : /* Return result */
11384 0 : *result = state->orig.out.result;
11385 :
11386 0 : tevent_req_received(req);
11387 0 : return NT_STATUS_OK;
11388 : }
11389 :
11390 0 : NTSTATUS dcerpc_clusapi_OnlineGroup(struct dcerpc_binding_handle *h,
11391 : TALLOC_CTX *mem_ctx,
11392 : struct policy_handle _hGroup /* [in] */,
11393 : WERROR *_rpc_status /* [out] [ref] */,
11394 : WERROR *result)
11395 : {
11396 : struct clusapi_OnlineGroup r;
11397 : NTSTATUS status;
11398 :
11399 : /* In parameters */
11400 0 : r.in.hGroup = _hGroup;
11401 :
11402 : /* Out parameters */
11403 0 : r.out.rpc_status = _rpc_status;
11404 :
11405 : /* Result */
11406 0 : NDR_ZERO_STRUCT(r.out.result);
11407 :
11408 0 : status = dcerpc_clusapi_OnlineGroup_r(h, mem_ctx, &r);
11409 0 : if (!NT_STATUS_IS_OK(status)) {
11410 0 : return status;
11411 : }
11412 :
11413 : /* Return variables */
11414 0 : *_rpc_status = *r.out.rpc_status;
11415 :
11416 : /* Return result */
11417 0 : *result = r.out.result;
11418 :
11419 0 : return NT_STATUS_OK;
11420 : }
11421 :
11422 : struct dcerpc_clusapi_OfflineGroup_r_state {
11423 : TALLOC_CTX *out_mem_ctx;
11424 : };
11425 :
11426 : static void dcerpc_clusapi_OfflineGroup_r_done(struct tevent_req *subreq);
11427 :
11428 0 : struct tevent_req *dcerpc_clusapi_OfflineGroup_r_send(TALLOC_CTX *mem_ctx,
11429 : struct tevent_context *ev,
11430 : struct dcerpc_binding_handle *h,
11431 : struct clusapi_OfflineGroup *r)
11432 : {
11433 : struct tevent_req *req;
11434 : struct dcerpc_clusapi_OfflineGroup_r_state *state;
11435 : struct tevent_req *subreq;
11436 :
11437 0 : req = tevent_req_create(mem_ctx, &state,
11438 : struct dcerpc_clusapi_OfflineGroup_r_state);
11439 0 : if (req == NULL) {
11440 0 : return NULL;
11441 : }
11442 :
11443 0 : state->out_mem_ctx = talloc_new(state);
11444 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11445 0 : return tevent_req_post(req, ev);
11446 : }
11447 :
11448 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
11449 : NULL, &ndr_table_clusapi,
11450 0 : NDR_CLUSAPI_OFFLINEGROUP, state->out_mem_ctx, r);
11451 0 : if (tevent_req_nomem(subreq, req)) {
11452 0 : return tevent_req_post(req, ev);
11453 : }
11454 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineGroup_r_done, req);
11455 :
11456 0 : return req;
11457 : }
11458 :
11459 0 : static void dcerpc_clusapi_OfflineGroup_r_done(struct tevent_req *subreq)
11460 : {
11461 0 : struct tevent_req *req =
11462 0 : tevent_req_callback_data(subreq,
11463 : struct tevent_req);
11464 : NTSTATUS status;
11465 :
11466 0 : status = dcerpc_binding_handle_call_recv(subreq);
11467 0 : TALLOC_FREE(subreq);
11468 0 : if (tevent_req_nterror(req, status)) {
11469 0 : return;
11470 : }
11471 :
11472 0 : tevent_req_done(req);
11473 : }
11474 :
11475 0 : NTSTATUS dcerpc_clusapi_OfflineGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
11476 : {
11477 0 : struct dcerpc_clusapi_OfflineGroup_r_state *state =
11478 0 : tevent_req_data(req,
11479 : struct dcerpc_clusapi_OfflineGroup_r_state);
11480 : NTSTATUS status;
11481 :
11482 0 : if (tevent_req_is_nterror(req, &status)) {
11483 0 : tevent_req_received(req);
11484 0 : return status;
11485 : }
11486 :
11487 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11488 :
11489 0 : tevent_req_received(req);
11490 0 : return NT_STATUS_OK;
11491 : }
11492 :
11493 0 : NTSTATUS dcerpc_clusapi_OfflineGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OfflineGroup *r)
11494 : {
11495 : NTSTATUS status;
11496 :
11497 0 : status = dcerpc_binding_handle_call(h,
11498 : NULL, &ndr_table_clusapi,
11499 : NDR_CLUSAPI_OFFLINEGROUP, mem_ctx, r);
11500 :
11501 0 : return status;
11502 : }
11503 :
11504 : struct dcerpc_clusapi_OfflineGroup_state {
11505 : struct clusapi_OfflineGroup orig;
11506 : struct clusapi_OfflineGroup tmp;
11507 : TALLOC_CTX *out_mem_ctx;
11508 : };
11509 :
11510 : static void dcerpc_clusapi_OfflineGroup_done(struct tevent_req *subreq);
11511 :
11512 0 : struct tevent_req *dcerpc_clusapi_OfflineGroup_send(TALLOC_CTX *mem_ctx,
11513 : struct tevent_context *ev,
11514 : struct dcerpc_binding_handle *h,
11515 : struct policy_handle _hGroup /* [in] */,
11516 : WERROR *_rpc_status /* [out] [ref] */)
11517 : {
11518 : struct tevent_req *req;
11519 : struct dcerpc_clusapi_OfflineGroup_state *state;
11520 : struct tevent_req *subreq;
11521 :
11522 0 : req = tevent_req_create(mem_ctx, &state,
11523 : struct dcerpc_clusapi_OfflineGroup_state);
11524 0 : if (req == NULL) {
11525 0 : return NULL;
11526 : }
11527 0 : state->out_mem_ctx = NULL;
11528 :
11529 : /* In parameters */
11530 0 : state->orig.in.hGroup = _hGroup;
11531 :
11532 : /* Out parameters */
11533 0 : state->orig.out.rpc_status = _rpc_status;
11534 :
11535 : /* Result */
11536 0 : NDR_ZERO_STRUCT(state->orig.out.result);
11537 :
11538 0 : state->out_mem_ctx = talloc_named_const(state, 0,
11539 : "dcerpc_clusapi_OfflineGroup_out_memory");
11540 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11541 0 : return tevent_req_post(req, ev);
11542 : }
11543 :
11544 : /* make a temporary copy, that we pass to the dispatch function */
11545 0 : state->tmp = state->orig;
11546 :
11547 0 : subreq = dcerpc_clusapi_OfflineGroup_r_send(state, ev, h, &state->tmp);
11548 0 : if (tevent_req_nomem(subreq, req)) {
11549 0 : return tevent_req_post(req, ev);
11550 : }
11551 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineGroup_done, req);
11552 0 : return req;
11553 : }
11554 :
11555 0 : static void dcerpc_clusapi_OfflineGroup_done(struct tevent_req *subreq)
11556 : {
11557 0 : struct tevent_req *req = tevent_req_callback_data(
11558 : subreq, struct tevent_req);
11559 0 : struct dcerpc_clusapi_OfflineGroup_state *state = tevent_req_data(
11560 : req, struct dcerpc_clusapi_OfflineGroup_state);
11561 : NTSTATUS status;
11562 : TALLOC_CTX *mem_ctx;
11563 :
11564 0 : if (state->out_mem_ctx) {
11565 0 : mem_ctx = state->out_mem_ctx;
11566 : } else {
11567 0 : mem_ctx = state;
11568 : }
11569 :
11570 0 : status = dcerpc_clusapi_OfflineGroup_r_recv(subreq, mem_ctx);
11571 0 : TALLOC_FREE(subreq);
11572 0 : if (tevent_req_nterror(req, status)) {
11573 0 : return;
11574 : }
11575 :
11576 : /* Copy out parameters */
11577 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
11578 :
11579 : /* Copy result */
11580 0 : state->orig.out.result = state->tmp.out.result;
11581 :
11582 : /* Reset temporary structure */
11583 0 : NDR_ZERO_STRUCT(state->tmp);
11584 :
11585 0 : tevent_req_done(req);
11586 : }
11587 :
11588 0 : NTSTATUS dcerpc_clusapi_OfflineGroup_recv(struct tevent_req *req,
11589 : TALLOC_CTX *mem_ctx,
11590 : WERROR *result)
11591 : {
11592 0 : struct dcerpc_clusapi_OfflineGroup_state *state = tevent_req_data(
11593 : req, struct dcerpc_clusapi_OfflineGroup_state);
11594 : NTSTATUS status;
11595 :
11596 0 : if (tevent_req_is_nterror(req, &status)) {
11597 0 : tevent_req_received(req);
11598 0 : return status;
11599 : }
11600 :
11601 : /* Steal possible out parameters to the callers context */
11602 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11603 :
11604 : /* Return result */
11605 0 : *result = state->orig.out.result;
11606 :
11607 0 : tevent_req_received(req);
11608 0 : return NT_STATUS_OK;
11609 : }
11610 :
11611 0 : NTSTATUS dcerpc_clusapi_OfflineGroup(struct dcerpc_binding_handle *h,
11612 : TALLOC_CTX *mem_ctx,
11613 : struct policy_handle _hGroup /* [in] */,
11614 : WERROR *_rpc_status /* [out] [ref] */,
11615 : WERROR *result)
11616 : {
11617 : struct clusapi_OfflineGroup r;
11618 : NTSTATUS status;
11619 :
11620 : /* In parameters */
11621 0 : r.in.hGroup = _hGroup;
11622 :
11623 : /* Out parameters */
11624 0 : r.out.rpc_status = _rpc_status;
11625 :
11626 : /* Result */
11627 0 : NDR_ZERO_STRUCT(r.out.result);
11628 :
11629 0 : status = dcerpc_clusapi_OfflineGroup_r(h, mem_ctx, &r);
11630 0 : if (!NT_STATUS_IS_OK(status)) {
11631 0 : return status;
11632 : }
11633 :
11634 : /* Return variables */
11635 0 : *_rpc_status = *r.out.rpc_status;
11636 :
11637 : /* Return result */
11638 0 : *result = r.out.result;
11639 :
11640 0 : return NT_STATUS_OK;
11641 : }
11642 :
11643 : struct dcerpc_clusapi_MoveGroup_r_state {
11644 : TALLOC_CTX *out_mem_ctx;
11645 : };
11646 :
11647 : static void dcerpc_clusapi_MoveGroup_r_done(struct tevent_req *subreq);
11648 :
11649 0 : struct tevent_req *dcerpc_clusapi_MoveGroup_r_send(TALLOC_CTX *mem_ctx,
11650 : struct tevent_context *ev,
11651 : struct dcerpc_binding_handle *h,
11652 : struct clusapi_MoveGroup *r)
11653 : {
11654 : struct tevent_req *req;
11655 : struct dcerpc_clusapi_MoveGroup_r_state *state;
11656 : struct tevent_req *subreq;
11657 :
11658 0 : req = tevent_req_create(mem_ctx, &state,
11659 : struct dcerpc_clusapi_MoveGroup_r_state);
11660 0 : if (req == NULL) {
11661 0 : return NULL;
11662 : }
11663 :
11664 0 : state->out_mem_ctx = talloc_new(state);
11665 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11666 0 : return tevent_req_post(req, ev);
11667 : }
11668 :
11669 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
11670 : NULL, &ndr_table_clusapi,
11671 0 : NDR_CLUSAPI_MOVEGROUP, state->out_mem_ctx, r);
11672 0 : if (tevent_req_nomem(subreq, req)) {
11673 0 : return tevent_req_post(req, ev);
11674 : }
11675 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroup_r_done, req);
11676 :
11677 0 : return req;
11678 : }
11679 :
11680 0 : static void dcerpc_clusapi_MoveGroup_r_done(struct tevent_req *subreq)
11681 : {
11682 0 : struct tevent_req *req =
11683 0 : tevent_req_callback_data(subreq,
11684 : struct tevent_req);
11685 : NTSTATUS status;
11686 :
11687 0 : status = dcerpc_binding_handle_call_recv(subreq);
11688 0 : TALLOC_FREE(subreq);
11689 0 : if (tevent_req_nterror(req, status)) {
11690 0 : return;
11691 : }
11692 :
11693 0 : tevent_req_done(req);
11694 : }
11695 :
11696 0 : NTSTATUS dcerpc_clusapi_MoveGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
11697 : {
11698 0 : struct dcerpc_clusapi_MoveGroup_r_state *state =
11699 0 : tevent_req_data(req,
11700 : struct dcerpc_clusapi_MoveGroup_r_state);
11701 : NTSTATUS status;
11702 :
11703 0 : if (tevent_req_is_nterror(req, &status)) {
11704 0 : tevent_req_received(req);
11705 0 : return status;
11706 : }
11707 :
11708 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11709 :
11710 0 : tevent_req_received(req);
11711 0 : return NT_STATUS_OK;
11712 : }
11713 :
11714 0 : NTSTATUS dcerpc_clusapi_MoveGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_MoveGroup *r)
11715 : {
11716 : NTSTATUS status;
11717 :
11718 0 : status = dcerpc_binding_handle_call(h,
11719 : NULL, &ndr_table_clusapi,
11720 : NDR_CLUSAPI_MOVEGROUP, mem_ctx, r);
11721 :
11722 0 : return status;
11723 : }
11724 :
11725 : struct dcerpc_clusapi_MoveGroup_state {
11726 : struct clusapi_MoveGroup orig;
11727 : struct clusapi_MoveGroup tmp;
11728 : TALLOC_CTX *out_mem_ctx;
11729 : };
11730 :
11731 : static void dcerpc_clusapi_MoveGroup_done(struct tevent_req *subreq);
11732 :
11733 0 : struct tevent_req *dcerpc_clusapi_MoveGroup_send(TALLOC_CTX *mem_ctx,
11734 : struct tevent_context *ev,
11735 : struct dcerpc_binding_handle *h,
11736 : struct policy_handle _hGroup /* [in] */,
11737 : WERROR *_rpc_status /* [out] [ref] */)
11738 : {
11739 : struct tevent_req *req;
11740 : struct dcerpc_clusapi_MoveGroup_state *state;
11741 : struct tevent_req *subreq;
11742 :
11743 0 : req = tevent_req_create(mem_ctx, &state,
11744 : struct dcerpc_clusapi_MoveGroup_state);
11745 0 : if (req == NULL) {
11746 0 : return NULL;
11747 : }
11748 0 : state->out_mem_ctx = NULL;
11749 :
11750 : /* In parameters */
11751 0 : state->orig.in.hGroup = _hGroup;
11752 :
11753 : /* Out parameters */
11754 0 : state->orig.out.rpc_status = _rpc_status;
11755 :
11756 : /* Result */
11757 0 : NDR_ZERO_STRUCT(state->orig.out.result);
11758 :
11759 0 : state->out_mem_ctx = talloc_named_const(state, 0,
11760 : "dcerpc_clusapi_MoveGroup_out_memory");
11761 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11762 0 : return tevent_req_post(req, ev);
11763 : }
11764 :
11765 : /* make a temporary copy, that we pass to the dispatch function */
11766 0 : state->tmp = state->orig;
11767 :
11768 0 : subreq = dcerpc_clusapi_MoveGroup_r_send(state, ev, h, &state->tmp);
11769 0 : if (tevent_req_nomem(subreq, req)) {
11770 0 : return tevent_req_post(req, ev);
11771 : }
11772 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroup_done, req);
11773 0 : return req;
11774 : }
11775 :
11776 0 : static void dcerpc_clusapi_MoveGroup_done(struct tevent_req *subreq)
11777 : {
11778 0 : struct tevent_req *req = tevent_req_callback_data(
11779 : subreq, struct tevent_req);
11780 0 : struct dcerpc_clusapi_MoveGroup_state *state = tevent_req_data(
11781 : req, struct dcerpc_clusapi_MoveGroup_state);
11782 : NTSTATUS status;
11783 : TALLOC_CTX *mem_ctx;
11784 :
11785 0 : if (state->out_mem_ctx) {
11786 0 : mem_ctx = state->out_mem_ctx;
11787 : } else {
11788 0 : mem_ctx = state;
11789 : }
11790 :
11791 0 : status = dcerpc_clusapi_MoveGroup_r_recv(subreq, mem_ctx);
11792 0 : TALLOC_FREE(subreq);
11793 0 : if (tevent_req_nterror(req, status)) {
11794 0 : return;
11795 : }
11796 :
11797 : /* Copy out parameters */
11798 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
11799 :
11800 : /* Copy result */
11801 0 : state->orig.out.result = state->tmp.out.result;
11802 :
11803 : /* Reset temporary structure */
11804 0 : NDR_ZERO_STRUCT(state->tmp);
11805 :
11806 0 : tevent_req_done(req);
11807 : }
11808 :
11809 0 : NTSTATUS dcerpc_clusapi_MoveGroup_recv(struct tevent_req *req,
11810 : TALLOC_CTX *mem_ctx,
11811 : WERROR *result)
11812 : {
11813 0 : struct dcerpc_clusapi_MoveGroup_state *state = tevent_req_data(
11814 : req, struct dcerpc_clusapi_MoveGroup_state);
11815 : NTSTATUS status;
11816 :
11817 0 : if (tevent_req_is_nterror(req, &status)) {
11818 0 : tevent_req_received(req);
11819 0 : return status;
11820 : }
11821 :
11822 : /* Steal possible out parameters to the callers context */
11823 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11824 :
11825 : /* Return result */
11826 0 : *result = state->orig.out.result;
11827 :
11828 0 : tevent_req_received(req);
11829 0 : return NT_STATUS_OK;
11830 : }
11831 :
11832 0 : NTSTATUS dcerpc_clusapi_MoveGroup(struct dcerpc_binding_handle *h,
11833 : TALLOC_CTX *mem_ctx,
11834 : struct policy_handle _hGroup /* [in] */,
11835 : WERROR *_rpc_status /* [out] [ref] */,
11836 : WERROR *result)
11837 : {
11838 : struct clusapi_MoveGroup r;
11839 : NTSTATUS status;
11840 :
11841 : /* In parameters */
11842 0 : r.in.hGroup = _hGroup;
11843 :
11844 : /* Out parameters */
11845 0 : r.out.rpc_status = _rpc_status;
11846 :
11847 : /* Result */
11848 0 : NDR_ZERO_STRUCT(r.out.result);
11849 :
11850 0 : status = dcerpc_clusapi_MoveGroup_r(h, mem_ctx, &r);
11851 0 : if (!NT_STATUS_IS_OK(status)) {
11852 0 : return status;
11853 : }
11854 :
11855 : /* Return variables */
11856 0 : *_rpc_status = *r.out.rpc_status;
11857 :
11858 : /* Return result */
11859 0 : *result = r.out.result;
11860 :
11861 0 : return NT_STATUS_OK;
11862 : }
11863 :
11864 : struct dcerpc_clusapi_MoveGroupToNode_r_state {
11865 : TALLOC_CTX *out_mem_ctx;
11866 : };
11867 :
11868 : static void dcerpc_clusapi_MoveGroupToNode_r_done(struct tevent_req *subreq);
11869 :
11870 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToNode_r_send(TALLOC_CTX *mem_ctx,
11871 : struct tevent_context *ev,
11872 : struct dcerpc_binding_handle *h,
11873 : struct clusapi_MoveGroupToNode *r)
11874 : {
11875 : struct tevent_req *req;
11876 : struct dcerpc_clusapi_MoveGroupToNode_r_state *state;
11877 : struct tevent_req *subreq;
11878 :
11879 0 : req = tevent_req_create(mem_ctx, &state,
11880 : struct dcerpc_clusapi_MoveGroupToNode_r_state);
11881 0 : if (req == NULL) {
11882 0 : return NULL;
11883 : }
11884 :
11885 0 : state->out_mem_ctx = talloc_new(state);
11886 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11887 0 : return tevent_req_post(req, ev);
11888 : }
11889 :
11890 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
11891 : NULL, &ndr_table_clusapi,
11892 0 : NDR_CLUSAPI_MOVEGROUPTONODE, state->out_mem_ctx, r);
11893 0 : if (tevent_req_nomem(subreq, req)) {
11894 0 : return tevent_req_post(req, ev);
11895 : }
11896 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToNode_r_done, req);
11897 :
11898 0 : return req;
11899 : }
11900 :
11901 0 : static void dcerpc_clusapi_MoveGroupToNode_r_done(struct tevent_req *subreq)
11902 : {
11903 0 : struct tevent_req *req =
11904 0 : tevent_req_callback_data(subreq,
11905 : struct tevent_req);
11906 : NTSTATUS status;
11907 :
11908 0 : status = dcerpc_binding_handle_call_recv(subreq);
11909 0 : TALLOC_FREE(subreq);
11910 0 : if (tevent_req_nterror(req, status)) {
11911 0 : return;
11912 : }
11913 :
11914 0 : tevent_req_done(req);
11915 : }
11916 :
11917 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
11918 : {
11919 0 : struct dcerpc_clusapi_MoveGroupToNode_r_state *state =
11920 0 : tevent_req_data(req,
11921 : struct dcerpc_clusapi_MoveGroupToNode_r_state);
11922 : NTSTATUS status;
11923 :
11924 0 : if (tevent_req_is_nterror(req, &status)) {
11925 0 : tevent_req_received(req);
11926 0 : return status;
11927 : }
11928 :
11929 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
11930 :
11931 0 : tevent_req_received(req);
11932 0 : return NT_STATUS_OK;
11933 : }
11934 :
11935 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_MoveGroupToNode *r)
11936 : {
11937 : NTSTATUS status;
11938 :
11939 0 : status = dcerpc_binding_handle_call(h,
11940 : NULL, &ndr_table_clusapi,
11941 : NDR_CLUSAPI_MOVEGROUPTONODE, mem_ctx, r);
11942 :
11943 0 : return status;
11944 : }
11945 :
11946 : struct dcerpc_clusapi_MoveGroupToNode_state {
11947 : struct clusapi_MoveGroupToNode orig;
11948 : struct clusapi_MoveGroupToNode tmp;
11949 : TALLOC_CTX *out_mem_ctx;
11950 : };
11951 :
11952 : static void dcerpc_clusapi_MoveGroupToNode_done(struct tevent_req *subreq);
11953 :
11954 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToNode_send(TALLOC_CTX *mem_ctx,
11955 : struct tevent_context *ev,
11956 : struct dcerpc_binding_handle *h,
11957 : struct policy_handle _hGroup /* [in] */,
11958 : struct policy_handle _hNode /* [in] */,
11959 : WERROR *_rpc_status /* [out] [ref] */)
11960 : {
11961 : struct tevent_req *req;
11962 : struct dcerpc_clusapi_MoveGroupToNode_state *state;
11963 : struct tevent_req *subreq;
11964 :
11965 0 : req = tevent_req_create(mem_ctx, &state,
11966 : struct dcerpc_clusapi_MoveGroupToNode_state);
11967 0 : if (req == NULL) {
11968 0 : return NULL;
11969 : }
11970 0 : state->out_mem_ctx = NULL;
11971 :
11972 : /* In parameters */
11973 0 : state->orig.in.hGroup = _hGroup;
11974 0 : state->orig.in.hNode = _hNode;
11975 :
11976 : /* Out parameters */
11977 0 : state->orig.out.rpc_status = _rpc_status;
11978 :
11979 : /* Result */
11980 0 : NDR_ZERO_STRUCT(state->orig.out.result);
11981 :
11982 0 : state->out_mem_ctx = talloc_named_const(state, 0,
11983 : "dcerpc_clusapi_MoveGroupToNode_out_memory");
11984 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
11985 0 : return tevent_req_post(req, ev);
11986 : }
11987 :
11988 : /* make a temporary copy, that we pass to the dispatch function */
11989 0 : state->tmp = state->orig;
11990 :
11991 0 : subreq = dcerpc_clusapi_MoveGroupToNode_r_send(state, ev, h, &state->tmp);
11992 0 : if (tevent_req_nomem(subreq, req)) {
11993 0 : return tevent_req_post(req, ev);
11994 : }
11995 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToNode_done, req);
11996 0 : return req;
11997 : }
11998 :
11999 0 : static void dcerpc_clusapi_MoveGroupToNode_done(struct tevent_req *subreq)
12000 : {
12001 0 : struct tevent_req *req = tevent_req_callback_data(
12002 : subreq, struct tevent_req);
12003 0 : struct dcerpc_clusapi_MoveGroupToNode_state *state = tevent_req_data(
12004 : req, struct dcerpc_clusapi_MoveGroupToNode_state);
12005 : NTSTATUS status;
12006 : TALLOC_CTX *mem_ctx;
12007 :
12008 0 : if (state->out_mem_ctx) {
12009 0 : mem_ctx = state->out_mem_ctx;
12010 : } else {
12011 0 : mem_ctx = state;
12012 : }
12013 :
12014 0 : status = dcerpc_clusapi_MoveGroupToNode_r_recv(subreq, mem_ctx);
12015 0 : TALLOC_FREE(subreq);
12016 0 : if (tevent_req_nterror(req, status)) {
12017 0 : return;
12018 : }
12019 :
12020 : /* Copy out parameters */
12021 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
12022 :
12023 : /* Copy result */
12024 0 : state->orig.out.result = state->tmp.out.result;
12025 :
12026 : /* Reset temporary structure */
12027 0 : NDR_ZERO_STRUCT(state->tmp);
12028 :
12029 0 : tevent_req_done(req);
12030 : }
12031 :
12032 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNode_recv(struct tevent_req *req,
12033 : TALLOC_CTX *mem_ctx,
12034 : WERROR *result)
12035 : {
12036 0 : struct dcerpc_clusapi_MoveGroupToNode_state *state = tevent_req_data(
12037 : req, struct dcerpc_clusapi_MoveGroupToNode_state);
12038 : NTSTATUS status;
12039 :
12040 0 : if (tevent_req_is_nterror(req, &status)) {
12041 0 : tevent_req_received(req);
12042 0 : return status;
12043 : }
12044 :
12045 : /* Steal possible out parameters to the callers context */
12046 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12047 :
12048 : /* Return result */
12049 0 : *result = state->orig.out.result;
12050 :
12051 0 : tevent_req_received(req);
12052 0 : return NT_STATUS_OK;
12053 : }
12054 :
12055 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNode(struct dcerpc_binding_handle *h,
12056 : TALLOC_CTX *mem_ctx,
12057 : struct policy_handle _hGroup /* [in] */,
12058 : struct policy_handle _hNode /* [in] */,
12059 : WERROR *_rpc_status /* [out] [ref] */,
12060 : WERROR *result)
12061 : {
12062 : struct clusapi_MoveGroupToNode r;
12063 : NTSTATUS status;
12064 :
12065 : /* In parameters */
12066 0 : r.in.hGroup = _hGroup;
12067 0 : r.in.hNode = _hNode;
12068 :
12069 : /* Out parameters */
12070 0 : r.out.rpc_status = _rpc_status;
12071 :
12072 : /* Result */
12073 0 : NDR_ZERO_STRUCT(r.out.result);
12074 :
12075 0 : status = dcerpc_clusapi_MoveGroupToNode_r(h, mem_ctx, &r);
12076 0 : if (!NT_STATUS_IS_OK(status)) {
12077 0 : return status;
12078 : }
12079 :
12080 : /* Return variables */
12081 0 : *_rpc_status = *r.out.rpc_status;
12082 :
12083 : /* Return result */
12084 0 : *result = r.out.result;
12085 :
12086 0 : return NT_STATUS_OK;
12087 : }
12088 :
12089 : struct dcerpc_clusapi_CreateGroupResourceEnum_r_state {
12090 : TALLOC_CTX *out_mem_ctx;
12091 : };
12092 :
12093 : static void dcerpc_clusapi_CreateGroupResourceEnum_r_done(struct tevent_req *subreq);
12094 :
12095 0 : struct tevent_req *dcerpc_clusapi_CreateGroupResourceEnum_r_send(TALLOC_CTX *mem_ctx,
12096 : struct tevent_context *ev,
12097 : struct dcerpc_binding_handle *h,
12098 : struct clusapi_CreateGroupResourceEnum *r)
12099 : {
12100 : struct tevent_req *req;
12101 : struct dcerpc_clusapi_CreateGroupResourceEnum_r_state *state;
12102 : struct tevent_req *subreq;
12103 :
12104 0 : req = tevent_req_create(mem_ctx, &state,
12105 : struct dcerpc_clusapi_CreateGroupResourceEnum_r_state);
12106 0 : if (req == NULL) {
12107 0 : return NULL;
12108 : }
12109 :
12110 0 : state->out_mem_ctx = talloc_new(state);
12111 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12112 0 : return tevent_req_post(req, ev);
12113 : }
12114 :
12115 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
12116 : NULL, &ndr_table_clusapi,
12117 0 : NDR_CLUSAPI_CREATEGROUPRESOURCEENUM, state->out_mem_ctx, r);
12118 0 : if (tevent_req_nomem(subreq, req)) {
12119 0 : return tevent_req_post(req, ev);
12120 : }
12121 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupResourceEnum_r_done, req);
12122 :
12123 0 : return req;
12124 : }
12125 :
12126 0 : static void dcerpc_clusapi_CreateGroupResourceEnum_r_done(struct tevent_req *subreq)
12127 : {
12128 0 : struct tevent_req *req =
12129 0 : tevent_req_callback_data(subreq,
12130 : struct tevent_req);
12131 : NTSTATUS status;
12132 :
12133 0 : status = dcerpc_binding_handle_call_recv(subreq);
12134 0 : TALLOC_FREE(subreq);
12135 0 : if (tevent_req_nterror(req, status)) {
12136 0 : return;
12137 : }
12138 :
12139 0 : tevent_req_done(req);
12140 : }
12141 :
12142 0 : NTSTATUS dcerpc_clusapi_CreateGroupResourceEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
12143 : {
12144 0 : struct dcerpc_clusapi_CreateGroupResourceEnum_r_state *state =
12145 0 : tevent_req_data(req,
12146 : struct dcerpc_clusapi_CreateGroupResourceEnum_r_state);
12147 : NTSTATUS status;
12148 :
12149 0 : if (tevent_req_is_nterror(req, &status)) {
12150 0 : tevent_req_received(req);
12151 0 : return status;
12152 : }
12153 :
12154 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12155 :
12156 0 : tevent_req_received(req);
12157 0 : return NT_STATUS_OK;
12158 : }
12159 :
12160 0 : NTSTATUS dcerpc_clusapi_CreateGroupResourceEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroupResourceEnum *r)
12161 : {
12162 : NTSTATUS status;
12163 :
12164 0 : status = dcerpc_binding_handle_call(h,
12165 : NULL, &ndr_table_clusapi,
12166 : NDR_CLUSAPI_CREATEGROUPRESOURCEENUM, mem_ctx, r);
12167 :
12168 0 : return status;
12169 : }
12170 :
12171 : struct dcerpc_clusapi_CreateGroupResourceEnum_state {
12172 : struct clusapi_CreateGroupResourceEnum orig;
12173 : struct clusapi_CreateGroupResourceEnum tmp;
12174 : TALLOC_CTX *out_mem_ctx;
12175 : };
12176 :
12177 : static void dcerpc_clusapi_CreateGroupResourceEnum_done(struct tevent_req *subreq);
12178 :
12179 0 : struct tevent_req *dcerpc_clusapi_CreateGroupResourceEnum_send(TALLOC_CTX *mem_ctx,
12180 : struct tevent_context *ev,
12181 : struct dcerpc_binding_handle *h,
12182 : struct policy_handle _hGroup /* [in] */,
12183 : uint32_t _dwType /* [in] */,
12184 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
12185 : WERROR *_rpc_status /* [out] [ref] */)
12186 : {
12187 : struct tevent_req *req;
12188 : struct dcerpc_clusapi_CreateGroupResourceEnum_state *state;
12189 : struct tevent_req *subreq;
12190 :
12191 0 : req = tevent_req_create(mem_ctx, &state,
12192 : struct dcerpc_clusapi_CreateGroupResourceEnum_state);
12193 0 : if (req == NULL) {
12194 0 : return NULL;
12195 : }
12196 0 : state->out_mem_ctx = NULL;
12197 :
12198 : /* In parameters */
12199 0 : state->orig.in.hGroup = _hGroup;
12200 0 : state->orig.in.dwType = _dwType;
12201 :
12202 : /* Out parameters */
12203 0 : state->orig.out.ReturnEnum = _ReturnEnum;
12204 0 : state->orig.out.rpc_status = _rpc_status;
12205 :
12206 : /* Result */
12207 0 : NDR_ZERO_STRUCT(state->orig.out.result);
12208 :
12209 0 : state->out_mem_ctx = talloc_named_const(state, 0,
12210 : "dcerpc_clusapi_CreateGroupResourceEnum_out_memory");
12211 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12212 0 : return tevent_req_post(req, ev);
12213 : }
12214 :
12215 : /* make a temporary copy, that we pass to the dispatch function */
12216 0 : state->tmp = state->orig;
12217 :
12218 0 : subreq = dcerpc_clusapi_CreateGroupResourceEnum_r_send(state, ev, h, &state->tmp);
12219 0 : if (tevent_req_nomem(subreq, req)) {
12220 0 : return tevent_req_post(req, ev);
12221 : }
12222 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupResourceEnum_done, req);
12223 0 : return req;
12224 : }
12225 :
12226 0 : static void dcerpc_clusapi_CreateGroupResourceEnum_done(struct tevent_req *subreq)
12227 : {
12228 0 : struct tevent_req *req = tevent_req_callback_data(
12229 : subreq, struct tevent_req);
12230 0 : struct dcerpc_clusapi_CreateGroupResourceEnum_state *state = tevent_req_data(
12231 : req, struct dcerpc_clusapi_CreateGroupResourceEnum_state);
12232 : NTSTATUS status;
12233 : TALLOC_CTX *mem_ctx;
12234 :
12235 0 : if (state->out_mem_ctx) {
12236 0 : mem_ctx = state->out_mem_ctx;
12237 : } else {
12238 0 : mem_ctx = state;
12239 : }
12240 :
12241 0 : status = dcerpc_clusapi_CreateGroupResourceEnum_r_recv(subreq, mem_ctx);
12242 0 : TALLOC_FREE(subreq);
12243 0 : if (tevent_req_nterror(req, status)) {
12244 0 : return;
12245 : }
12246 :
12247 : /* Copy out parameters */
12248 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
12249 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
12250 :
12251 : /* Copy result */
12252 0 : state->orig.out.result = state->tmp.out.result;
12253 :
12254 : /* Reset temporary structure */
12255 0 : NDR_ZERO_STRUCT(state->tmp);
12256 :
12257 0 : tevent_req_done(req);
12258 : }
12259 :
12260 0 : NTSTATUS dcerpc_clusapi_CreateGroupResourceEnum_recv(struct tevent_req *req,
12261 : TALLOC_CTX *mem_ctx,
12262 : WERROR *result)
12263 : {
12264 0 : struct dcerpc_clusapi_CreateGroupResourceEnum_state *state = tevent_req_data(
12265 : req, struct dcerpc_clusapi_CreateGroupResourceEnum_state);
12266 : NTSTATUS status;
12267 :
12268 0 : if (tevent_req_is_nterror(req, &status)) {
12269 0 : tevent_req_received(req);
12270 0 : return status;
12271 : }
12272 :
12273 : /* Steal possible out parameters to the callers context */
12274 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12275 :
12276 : /* Return result */
12277 0 : *result = state->orig.out.result;
12278 :
12279 0 : tevent_req_received(req);
12280 0 : return NT_STATUS_OK;
12281 : }
12282 :
12283 0 : NTSTATUS dcerpc_clusapi_CreateGroupResourceEnum(struct dcerpc_binding_handle *h,
12284 : TALLOC_CTX *mem_ctx,
12285 : struct policy_handle _hGroup /* [in] */,
12286 : uint32_t _dwType /* [in] */,
12287 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
12288 : WERROR *_rpc_status /* [out] [ref] */,
12289 : WERROR *result)
12290 : {
12291 : struct clusapi_CreateGroupResourceEnum r;
12292 : NTSTATUS status;
12293 :
12294 : /* In parameters */
12295 0 : r.in.hGroup = _hGroup;
12296 0 : r.in.dwType = _dwType;
12297 :
12298 : /* Out parameters */
12299 0 : r.out.ReturnEnum = _ReturnEnum;
12300 0 : r.out.rpc_status = _rpc_status;
12301 :
12302 : /* Result */
12303 0 : NDR_ZERO_STRUCT(r.out.result);
12304 :
12305 0 : status = dcerpc_clusapi_CreateGroupResourceEnum_r(h, mem_ctx, &r);
12306 0 : if (!NT_STATUS_IS_OK(status)) {
12307 0 : return status;
12308 : }
12309 :
12310 : /* Return variables */
12311 0 : *_ReturnEnum = *r.out.ReturnEnum;
12312 0 : *_rpc_status = *r.out.rpc_status;
12313 :
12314 : /* Return result */
12315 0 : *result = r.out.result;
12316 :
12317 0 : return NT_STATUS_OK;
12318 : }
12319 :
12320 : struct dcerpc_clusapi_SetGroupNodeList_r_state {
12321 : TALLOC_CTX *out_mem_ctx;
12322 : };
12323 :
12324 : static void dcerpc_clusapi_SetGroupNodeList_r_done(struct tevent_req *subreq);
12325 :
12326 0 : struct tevent_req *dcerpc_clusapi_SetGroupNodeList_r_send(TALLOC_CTX *mem_ctx,
12327 : struct tevent_context *ev,
12328 : struct dcerpc_binding_handle *h,
12329 : struct clusapi_SetGroupNodeList *r)
12330 : {
12331 : struct tevent_req *req;
12332 : struct dcerpc_clusapi_SetGroupNodeList_r_state *state;
12333 : struct tevent_req *subreq;
12334 :
12335 0 : req = tevent_req_create(mem_ctx, &state,
12336 : struct dcerpc_clusapi_SetGroupNodeList_r_state);
12337 0 : if (req == NULL) {
12338 0 : return NULL;
12339 : }
12340 :
12341 0 : state->out_mem_ctx = talloc_new(state);
12342 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12343 0 : return tevent_req_post(req, ev);
12344 : }
12345 :
12346 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
12347 : NULL, &ndr_table_clusapi,
12348 0 : NDR_CLUSAPI_SETGROUPNODELIST, state->out_mem_ctx, r);
12349 0 : if (tevent_req_nomem(subreq, req)) {
12350 0 : return tevent_req_post(req, ev);
12351 : }
12352 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupNodeList_r_done, req);
12353 :
12354 0 : return req;
12355 : }
12356 :
12357 0 : static void dcerpc_clusapi_SetGroupNodeList_r_done(struct tevent_req *subreq)
12358 : {
12359 0 : struct tevent_req *req =
12360 0 : tevent_req_callback_data(subreq,
12361 : struct tevent_req);
12362 : NTSTATUS status;
12363 :
12364 0 : status = dcerpc_binding_handle_call_recv(subreq);
12365 0 : TALLOC_FREE(subreq);
12366 0 : if (tevent_req_nterror(req, status)) {
12367 0 : return;
12368 : }
12369 :
12370 0 : tevent_req_done(req);
12371 : }
12372 :
12373 0 : NTSTATUS dcerpc_clusapi_SetGroupNodeList_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
12374 : {
12375 0 : struct dcerpc_clusapi_SetGroupNodeList_r_state *state =
12376 0 : tevent_req_data(req,
12377 : struct dcerpc_clusapi_SetGroupNodeList_r_state);
12378 : NTSTATUS status;
12379 :
12380 0 : if (tevent_req_is_nterror(req, &status)) {
12381 0 : tevent_req_received(req);
12382 0 : return status;
12383 : }
12384 :
12385 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12386 :
12387 0 : tevent_req_received(req);
12388 0 : return NT_STATUS_OK;
12389 : }
12390 :
12391 0 : NTSTATUS dcerpc_clusapi_SetGroupNodeList_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetGroupNodeList *r)
12392 : {
12393 : NTSTATUS status;
12394 :
12395 0 : status = dcerpc_binding_handle_call(h,
12396 : NULL, &ndr_table_clusapi,
12397 : NDR_CLUSAPI_SETGROUPNODELIST, mem_ctx, r);
12398 :
12399 0 : return status;
12400 : }
12401 :
12402 : struct dcerpc_clusapi_SetGroupNodeList_state {
12403 : struct clusapi_SetGroupNodeList orig;
12404 : struct clusapi_SetGroupNodeList tmp;
12405 : TALLOC_CTX *out_mem_ctx;
12406 : };
12407 :
12408 : static void dcerpc_clusapi_SetGroupNodeList_done(struct tevent_req *subreq);
12409 :
12410 0 : struct tevent_req *dcerpc_clusapi_SetGroupNodeList_send(TALLOC_CTX *mem_ctx,
12411 : struct tevent_context *ev,
12412 : struct dcerpc_binding_handle *h,
12413 : struct policy_handle _hGroup /* [in] */,
12414 : uint16_t *_multiSzNodeList /* [in] [size_is(cchListSize),unique] */,
12415 : uint32_t _cchListSize /* [in] */,
12416 : WERROR *_rpc_status /* [out] [ref] */)
12417 : {
12418 : struct tevent_req *req;
12419 : struct dcerpc_clusapi_SetGroupNodeList_state *state;
12420 : struct tevent_req *subreq;
12421 :
12422 0 : req = tevent_req_create(mem_ctx, &state,
12423 : struct dcerpc_clusapi_SetGroupNodeList_state);
12424 0 : if (req == NULL) {
12425 0 : return NULL;
12426 : }
12427 0 : state->out_mem_ctx = NULL;
12428 :
12429 : /* In parameters */
12430 0 : state->orig.in.hGroup = _hGroup;
12431 0 : state->orig.in.multiSzNodeList = _multiSzNodeList;
12432 0 : state->orig.in.cchListSize = _cchListSize;
12433 :
12434 : /* Out parameters */
12435 0 : state->orig.out.rpc_status = _rpc_status;
12436 :
12437 : /* Result */
12438 0 : NDR_ZERO_STRUCT(state->orig.out.result);
12439 :
12440 0 : state->out_mem_ctx = talloc_named_const(state, 0,
12441 : "dcerpc_clusapi_SetGroupNodeList_out_memory");
12442 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12443 0 : return tevent_req_post(req, ev);
12444 : }
12445 :
12446 : /* make a temporary copy, that we pass to the dispatch function */
12447 0 : state->tmp = state->orig;
12448 :
12449 0 : subreq = dcerpc_clusapi_SetGroupNodeList_r_send(state, ev, h, &state->tmp);
12450 0 : if (tevent_req_nomem(subreq, req)) {
12451 0 : return tevent_req_post(req, ev);
12452 : }
12453 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupNodeList_done, req);
12454 0 : return req;
12455 : }
12456 :
12457 0 : static void dcerpc_clusapi_SetGroupNodeList_done(struct tevent_req *subreq)
12458 : {
12459 0 : struct tevent_req *req = tevent_req_callback_data(
12460 : subreq, struct tevent_req);
12461 0 : struct dcerpc_clusapi_SetGroupNodeList_state *state = tevent_req_data(
12462 : req, struct dcerpc_clusapi_SetGroupNodeList_state);
12463 : NTSTATUS status;
12464 : TALLOC_CTX *mem_ctx;
12465 :
12466 0 : if (state->out_mem_ctx) {
12467 0 : mem_ctx = state->out_mem_ctx;
12468 : } else {
12469 0 : mem_ctx = state;
12470 : }
12471 :
12472 0 : status = dcerpc_clusapi_SetGroupNodeList_r_recv(subreq, mem_ctx);
12473 0 : TALLOC_FREE(subreq);
12474 0 : if (tevent_req_nterror(req, status)) {
12475 0 : return;
12476 : }
12477 :
12478 : /* Copy out parameters */
12479 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
12480 :
12481 : /* Copy result */
12482 0 : state->orig.out.result = state->tmp.out.result;
12483 :
12484 : /* Reset temporary structure */
12485 0 : NDR_ZERO_STRUCT(state->tmp);
12486 :
12487 0 : tevent_req_done(req);
12488 : }
12489 :
12490 0 : NTSTATUS dcerpc_clusapi_SetGroupNodeList_recv(struct tevent_req *req,
12491 : TALLOC_CTX *mem_ctx,
12492 : WERROR *result)
12493 : {
12494 0 : struct dcerpc_clusapi_SetGroupNodeList_state *state = tevent_req_data(
12495 : req, struct dcerpc_clusapi_SetGroupNodeList_state);
12496 : NTSTATUS status;
12497 :
12498 0 : if (tevent_req_is_nterror(req, &status)) {
12499 0 : tevent_req_received(req);
12500 0 : return status;
12501 : }
12502 :
12503 : /* Steal possible out parameters to the callers context */
12504 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12505 :
12506 : /* Return result */
12507 0 : *result = state->orig.out.result;
12508 :
12509 0 : tevent_req_received(req);
12510 0 : return NT_STATUS_OK;
12511 : }
12512 :
12513 0 : NTSTATUS dcerpc_clusapi_SetGroupNodeList(struct dcerpc_binding_handle *h,
12514 : TALLOC_CTX *mem_ctx,
12515 : struct policy_handle _hGroup /* [in] */,
12516 : uint16_t *_multiSzNodeList /* [in] [size_is(cchListSize),unique] */,
12517 : uint32_t _cchListSize /* [in] */,
12518 : WERROR *_rpc_status /* [out] [ref] */,
12519 : WERROR *result)
12520 : {
12521 : struct clusapi_SetGroupNodeList r;
12522 : NTSTATUS status;
12523 :
12524 : /* In parameters */
12525 0 : r.in.hGroup = _hGroup;
12526 0 : r.in.multiSzNodeList = _multiSzNodeList;
12527 0 : r.in.cchListSize = _cchListSize;
12528 :
12529 : /* Out parameters */
12530 0 : r.out.rpc_status = _rpc_status;
12531 :
12532 : /* Result */
12533 0 : NDR_ZERO_STRUCT(r.out.result);
12534 :
12535 0 : status = dcerpc_clusapi_SetGroupNodeList_r(h, mem_ctx, &r);
12536 0 : if (!NT_STATUS_IS_OK(status)) {
12537 0 : return status;
12538 : }
12539 :
12540 : /* Return variables */
12541 0 : *_rpc_status = *r.out.rpc_status;
12542 :
12543 : /* Return result */
12544 0 : *result = r.out.result;
12545 :
12546 0 : return NT_STATUS_OK;
12547 : }
12548 :
12549 : struct dcerpc_clusapi_CreateNotify_r_state {
12550 : TALLOC_CTX *out_mem_ctx;
12551 : };
12552 :
12553 : static void dcerpc_clusapi_CreateNotify_r_done(struct tevent_req *subreq);
12554 :
12555 0 : struct tevent_req *dcerpc_clusapi_CreateNotify_r_send(TALLOC_CTX *mem_ctx,
12556 : struct tevent_context *ev,
12557 : struct dcerpc_binding_handle *h,
12558 : struct clusapi_CreateNotify *r)
12559 : {
12560 : struct tevent_req *req;
12561 : struct dcerpc_clusapi_CreateNotify_r_state *state;
12562 : struct tevent_req *subreq;
12563 :
12564 0 : req = tevent_req_create(mem_ctx, &state,
12565 : struct dcerpc_clusapi_CreateNotify_r_state);
12566 0 : if (req == NULL) {
12567 0 : return NULL;
12568 : }
12569 :
12570 0 : state->out_mem_ctx = talloc_new(state);
12571 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12572 0 : return tevent_req_post(req, ev);
12573 : }
12574 :
12575 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
12576 : NULL, &ndr_table_clusapi,
12577 0 : NDR_CLUSAPI_CREATENOTIFY, state->out_mem_ctx, r);
12578 0 : if (tevent_req_nomem(subreq, req)) {
12579 0 : return tevent_req_post(req, ev);
12580 : }
12581 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNotify_r_done, req);
12582 :
12583 0 : return req;
12584 : }
12585 :
12586 0 : static void dcerpc_clusapi_CreateNotify_r_done(struct tevent_req *subreq)
12587 : {
12588 0 : struct tevent_req *req =
12589 0 : tevent_req_callback_data(subreq,
12590 : struct tevent_req);
12591 : NTSTATUS status;
12592 :
12593 0 : status = dcerpc_binding_handle_call_recv(subreq);
12594 0 : TALLOC_FREE(subreq);
12595 0 : if (tevent_req_nterror(req, status)) {
12596 0 : return;
12597 : }
12598 :
12599 0 : tevent_req_done(req);
12600 : }
12601 :
12602 0 : NTSTATUS dcerpc_clusapi_CreateNotify_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
12603 : {
12604 0 : struct dcerpc_clusapi_CreateNotify_r_state *state =
12605 0 : tevent_req_data(req,
12606 : struct dcerpc_clusapi_CreateNotify_r_state);
12607 : NTSTATUS status;
12608 :
12609 0 : if (tevent_req_is_nterror(req, &status)) {
12610 0 : tevent_req_received(req);
12611 0 : return status;
12612 : }
12613 :
12614 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12615 :
12616 0 : tevent_req_received(req);
12617 0 : return NT_STATUS_OK;
12618 : }
12619 :
12620 0 : NTSTATUS dcerpc_clusapi_CreateNotify_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNotify *r)
12621 : {
12622 : NTSTATUS status;
12623 :
12624 0 : status = dcerpc_binding_handle_call(h,
12625 : NULL, &ndr_table_clusapi,
12626 : NDR_CLUSAPI_CREATENOTIFY, mem_ctx, r);
12627 :
12628 0 : return status;
12629 : }
12630 :
12631 : struct dcerpc_clusapi_CreateNotify_state {
12632 : struct clusapi_CreateNotify orig;
12633 : struct clusapi_CreateNotify tmp;
12634 : TALLOC_CTX *out_mem_ctx;
12635 : };
12636 :
12637 : static void dcerpc_clusapi_CreateNotify_done(struct tevent_req *subreq);
12638 :
12639 0 : struct tevent_req *dcerpc_clusapi_CreateNotify_send(TALLOC_CTX *mem_ctx,
12640 : struct tevent_context *ev,
12641 : struct dcerpc_binding_handle *h,
12642 : WERROR *_Status /* [out] [ref] */,
12643 : WERROR *_rpc_status /* [out] [ref] */,
12644 : struct policy_handle *_hNotify /* [out] [ref] */)
12645 : {
12646 : struct tevent_req *req;
12647 : struct dcerpc_clusapi_CreateNotify_state *state;
12648 : struct tevent_req *subreq;
12649 :
12650 0 : req = tevent_req_create(mem_ctx, &state,
12651 : struct dcerpc_clusapi_CreateNotify_state);
12652 0 : if (req == NULL) {
12653 0 : return NULL;
12654 : }
12655 0 : state->out_mem_ctx = NULL;
12656 :
12657 : /* In parameters */
12658 :
12659 : /* Out parameters */
12660 0 : state->orig.out.Status = _Status;
12661 0 : state->orig.out.rpc_status = _rpc_status;
12662 0 : state->orig.out.hNotify = _hNotify;
12663 :
12664 0 : state->out_mem_ctx = talloc_named_const(state, 0,
12665 : "dcerpc_clusapi_CreateNotify_out_memory");
12666 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12667 0 : return tevent_req_post(req, ev);
12668 : }
12669 :
12670 : /* make a temporary copy, that we pass to the dispatch function */
12671 0 : state->tmp = state->orig;
12672 :
12673 0 : subreq = dcerpc_clusapi_CreateNotify_r_send(state, ev, h, &state->tmp);
12674 0 : if (tevent_req_nomem(subreq, req)) {
12675 0 : return tevent_req_post(req, ev);
12676 : }
12677 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNotify_done, req);
12678 0 : return req;
12679 : }
12680 :
12681 0 : static void dcerpc_clusapi_CreateNotify_done(struct tevent_req *subreq)
12682 : {
12683 0 : struct tevent_req *req = tevent_req_callback_data(
12684 : subreq, struct tevent_req);
12685 0 : struct dcerpc_clusapi_CreateNotify_state *state = tevent_req_data(
12686 : req, struct dcerpc_clusapi_CreateNotify_state);
12687 : NTSTATUS status;
12688 : TALLOC_CTX *mem_ctx;
12689 :
12690 0 : if (state->out_mem_ctx) {
12691 0 : mem_ctx = state->out_mem_ctx;
12692 : } else {
12693 0 : mem_ctx = state;
12694 : }
12695 :
12696 0 : status = dcerpc_clusapi_CreateNotify_r_recv(subreq, mem_ctx);
12697 0 : TALLOC_FREE(subreq);
12698 0 : if (tevent_req_nterror(req, status)) {
12699 0 : return;
12700 : }
12701 :
12702 : /* Copy out parameters */
12703 0 : *state->orig.out.Status = *state->tmp.out.Status;
12704 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
12705 0 : *state->orig.out.hNotify = *state->tmp.out.hNotify;
12706 :
12707 : /* Reset temporary structure */
12708 0 : NDR_ZERO_STRUCT(state->tmp);
12709 :
12710 0 : tevent_req_done(req);
12711 : }
12712 :
12713 0 : NTSTATUS dcerpc_clusapi_CreateNotify_recv(struct tevent_req *req,
12714 : TALLOC_CTX *mem_ctx)
12715 : {
12716 0 : struct dcerpc_clusapi_CreateNotify_state *state = tevent_req_data(
12717 : req, struct dcerpc_clusapi_CreateNotify_state);
12718 : NTSTATUS status;
12719 :
12720 0 : if (tevent_req_is_nterror(req, &status)) {
12721 0 : tevent_req_received(req);
12722 0 : return status;
12723 : }
12724 :
12725 : /* Steal possible out parameters to the callers context */
12726 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12727 :
12728 0 : tevent_req_received(req);
12729 0 : return NT_STATUS_OK;
12730 : }
12731 :
12732 0 : NTSTATUS dcerpc_clusapi_CreateNotify(struct dcerpc_binding_handle *h,
12733 : TALLOC_CTX *mem_ctx,
12734 : WERROR *_Status /* [out] [ref] */,
12735 : WERROR *_rpc_status /* [out] [ref] */,
12736 : struct policy_handle *_hNotify /* [out] [ref] */)
12737 : {
12738 : struct clusapi_CreateNotify r;
12739 : NTSTATUS status;
12740 :
12741 : /* In parameters */
12742 :
12743 : /* Out parameters */
12744 0 : r.out.Status = _Status;
12745 0 : r.out.rpc_status = _rpc_status;
12746 0 : r.out.hNotify = _hNotify;
12747 :
12748 0 : status = dcerpc_clusapi_CreateNotify_r(h, mem_ctx, &r);
12749 0 : if (!NT_STATUS_IS_OK(status)) {
12750 0 : return status;
12751 : }
12752 :
12753 : /* Return variables */
12754 0 : *_Status = *r.out.Status;
12755 0 : *_rpc_status = *r.out.rpc_status;
12756 0 : *_hNotify = *r.out.hNotify;
12757 :
12758 : /* Return result */
12759 :
12760 0 : return NT_STATUS_OK;
12761 : }
12762 :
12763 : struct dcerpc_clusapi_CloseNotify_r_state {
12764 : TALLOC_CTX *out_mem_ctx;
12765 : };
12766 :
12767 : static void dcerpc_clusapi_CloseNotify_r_done(struct tevent_req *subreq);
12768 :
12769 0 : struct tevent_req *dcerpc_clusapi_CloseNotify_r_send(TALLOC_CTX *mem_ctx,
12770 : struct tevent_context *ev,
12771 : struct dcerpc_binding_handle *h,
12772 : struct clusapi_CloseNotify *r)
12773 : {
12774 : struct tevent_req *req;
12775 : struct dcerpc_clusapi_CloseNotify_r_state *state;
12776 : struct tevent_req *subreq;
12777 :
12778 0 : req = tevent_req_create(mem_ctx, &state,
12779 : struct dcerpc_clusapi_CloseNotify_r_state);
12780 0 : if (req == NULL) {
12781 0 : return NULL;
12782 : }
12783 :
12784 0 : state->out_mem_ctx = talloc_new(state);
12785 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12786 0 : return tevent_req_post(req, ev);
12787 : }
12788 :
12789 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
12790 : NULL, &ndr_table_clusapi,
12791 0 : NDR_CLUSAPI_CLOSENOTIFY, state->out_mem_ctx, r);
12792 0 : if (tevent_req_nomem(subreq, req)) {
12793 0 : return tevent_req_post(req, ev);
12794 : }
12795 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNotify_r_done, req);
12796 :
12797 0 : return req;
12798 : }
12799 :
12800 0 : static void dcerpc_clusapi_CloseNotify_r_done(struct tevent_req *subreq)
12801 : {
12802 0 : struct tevent_req *req =
12803 0 : tevent_req_callback_data(subreq,
12804 : struct tevent_req);
12805 : NTSTATUS status;
12806 :
12807 0 : status = dcerpc_binding_handle_call_recv(subreq);
12808 0 : TALLOC_FREE(subreq);
12809 0 : if (tevent_req_nterror(req, status)) {
12810 0 : return;
12811 : }
12812 :
12813 0 : tevent_req_done(req);
12814 : }
12815 :
12816 0 : NTSTATUS dcerpc_clusapi_CloseNotify_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
12817 : {
12818 0 : struct dcerpc_clusapi_CloseNotify_r_state *state =
12819 0 : tevent_req_data(req,
12820 : struct dcerpc_clusapi_CloseNotify_r_state);
12821 : NTSTATUS status;
12822 :
12823 0 : if (tevent_req_is_nterror(req, &status)) {
12824 0 : tevent_req_received(req);
12825 0 : return status;
12826 : }
12827 :
12828 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12829 :
12830 0 : tevent_req_received(req);
12831 0 : return NT_STATUS_OK;
12832 : }
12833 :
12834 0 : NTSTATUS dcerpc_clusapi_CloseNotify_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseNotify *r)
12835 : {
12836 : NTSTATUS status;
12837 :
12838 0 : status = dcerpc_binding_handle_call(h,
12839 : NULL, &ndr_table_clusapi,
12840 : NDR_CLUSAPI_CLOSENOTIFY, mem_ctx, r);
12841 :
12842 0 : return status;
12843 : }
12844 :
12845 : struct dcerpc_clusapi_CloseNotify_state {
12846 : struct clusapi_CloseNotify orig;
12847 : struct clusapi_CloseNotify tmp;
12848 : TALLOC_CTX *out_mem_ctx;
12849 : };
12850 :
12851 : static void dcerpc_clusapi_CloseNotify_done(struct tevent_req *subreq);
12852 :
12853 0 : struct tevent_req *dcerpc_clusapi_CloseNotify_send(TALLOC_CTX *mem_ctx,
12854 : struct tevent_context *ev,
12855 : struct dcerpc_binding_handle *h,
12856 : struct policy_handle *_Notify /* [in,out] [ref] */)
12857 : {
12858 : struct tevent_req *req;
12859 : struct dcerpc_clusapi_CloseNotify_state *state;
12860 : struct tevent_req *subreq;
12861 :
12862 0 : req = tevent_req_create(mem_ctx, &state,
12863 : struct dcerpc_clusapi_CloseNotify_state);
12864 0 : if (req == NULL) {
12865 0 : return NULL;
12866 : }
12867 0 : state->out_mem_ctx = NULL;
12868 :
12869 : /* In parameters */
12870 0 : state->orig.in.Notify = _Notify;
12871 :
12872 : /* Out parameters */
12873 0 : state->orig.out.Notify = _Notify;
12874 :
12875 : /* Result */
12876 0 : NDR_ZERO_STRUCT(state->orig.out.result);
12877 :
12878 0 : state->out_mem_ctx = talloc_named_const(state, 0,
12879 : "dcerpc_clusapi_CloseNotify_out_memory");
12880 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
12881 0 : return tevent_req_post(req, ev);
12882 : }
12883 :
12884 : /* make a temporary copy, that we pass to the dispatch function */
12885 0 : state->tmp = state->orig;
12886 :
12887 0 : subreq = dcerpc_clusapi_CloseNotify_r_send(state, ev, h, &state->tmp);
12888 0 : if (tevent_req_nomem(subreq, req)) {
12889 0 : return tevent_req_post(req, ev);
12890 : }
12891 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNotify_done, req);
12892 0 : return req;
12893 : }
12894 :
12895 0 : static void dcerpc_clusapi_CloseNotify_done(struct tevent_req *subreq)
12896 : {
12897 0 : struct tevent_req *req = tevent_req_callback_data(
12898 : subreq, struct tevent_req);
12899 0 : struct dcerpc_clusapi_CloseNotify_state *state = tevent_req_data(
12900 : req, struct dcerpc_clusapi_CloseNotify_state);
12901 : NTSTATUS status;
12902 : TALLOC_CTX *mem_ctx;
12903 :
12904 0 : if (state->out_mem_ctx) {
12905 0 : mem_ctx = state->out_mem_ctx;
12906 : } else {
12907 0 : mem_ctx = state;
12908 : }
12909 :
12910 0 : status = dcerpc_clusapi_CloseNotify_r_recv(subreq, mem_ctx);
12911 0 : TALLOC_FREE(subreq);
12912 0 : if (tevent_req_nterror(req, status)) {
12913 0 : return;
12914 : }
12915 :
12916 : /* Copy out parameters */
12917 0 : *state->orig.out.Notify = *state->tmp.out.Notify;
12918 :
12919 : /* Copy result */
12920 0 : state->orig.out.result = state->tmp.out.result;
12921 :
12922 : /* Reset temporary structure */
12923 0 : NDR_ZERO_STRUCT(state->tmp);
12924 :
12925 0 : tevent_req_done(req);
12926 : }
12927 :
12928 0 : NTSTATUS dcerpc_clusapi_CloseNotify_recv(struct tevent_req *req,
12929 : TALLOC_CTX *mem_ctx,
12930 : WERROR *result)
12931 : {
12932 0 : struct dcerpc_clusapi_CloseNotify_state *state = tevent_req_data(
12933 : req, struct dcerpc_clusapi_CloseNotify_state);
12934 : NTSTATUS status;
12935 :
12936 0 : if (tevent_req_is_nterror(req, &status)) {
12937 0 : tevent_req_received(req);
12938 0 : return status;
12939 : }
12940 :
12941 : /* Steal possible out parameters to the callers context */
12942 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
12943 :
12944 : /* Return result */
12945 0 : *result = state->orig.out.result;
12946 :
12947 0 : tevent_req_received(req);
12948 0 : return NT_STATUS_OK;
12949 : }
12950 :
12951 0 : NTSTATUS dcerpc_clusapi_CloseNotify(struct dcerpc_binding_handle *h,
12952 : TALLOC_CTX *mem_ctx,
12953 : struct policy_handle *_Notify /* [in,out] [ref] */,
12954 : WERROR *result)
12955 : {
12956 : struct clusapi_CloseNotify r;
12957 : NTSTATUS status;
12958 :
12959 : /* In parameters */
12960 0 : r.in.Notify = _Notify;
12961 :
12962 : /* Out parameters */
12963 0 : r.out.Notify = _Notify;
12964 :
12965 : /* Result */
12966 0 : NDR_ZERO_STRUCT(r.out.result);
12967 :
12968 0 : status = dcerpc_clusapi_CloseNotify_r(h, mem_ctx, &r);
12969 0 : if (!NT_STATUS_IS_OK(status)) {
12970 0 : return status;
12971 : }
12972 :
12973 : /* Return variables */
12974 0 : *_Notify = *r.out.Notify;
12975 :
12976 : /* Return result */
12977 0 : *result = r.out.result;
12978 :
12979 0 : return NT_STATUS_OK;
12980 : }
12981 :
12982 : struct dcerpc_clusapi_AddNotifyCluster_r_state {
12983 : TALLOC_CTX *out_mem_ctx;
12984 : };
12985 :
12986 : static void dcerpc_clusapi_AddNotifyCluster_r_done(struct tevent_req *subreq);
12987 :
12988 0 : struct tevent_req *dcerpc_clusapi_AddNotifyCluster_r_send(TALLOC_CTX *mem_ctx,
12989 : struct tevent_context *ev,
12990 : struct dcerpc_binding_handle *h,
12991 : struct clusapi_AddNotifyCluster *r)
12992 : {
12993 : struct tevent_req *req;
12994 : struct dcerpc_clusapi_AddNotifyCluster_r_state *state;
12995 : struct tevent_req *subreq;
12996 :
12997 0 : req = tevent_req_create(mem_ctx, &state,
12998 : struct dcerpc_clusapi_AddNotifyCluster_r_state);
12999 0 : if (req == NULL) {
13000 0 : return NULL;
13001 : }
13002 :
13003 0 : state->out_mem_ctx = talloc_new(state);
13004 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13005 0 : return tevent_req_post(req, ev);
13006 : }
13007 :
13008 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
13009 : NULL, &ndr_table_clusapi,
13010 0 : NDR_CLUSAPI_ADDNOTIFYCLUSTER, state->out_mem_ctx, r);
13011 0 : if (tevent_req_nomem(subreq, req)) {
13012 0 : return tevent_req_post(req, ev);
13013 : }
13014 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyCluster_r_done, req);
13015 :
13016 0 : return req;
13017 : }
13018 :
13019 0 : static void dcerpc_clusapi_AddNotifyCluster_r_done(struct tevent_req *subreq)
13020 : {
13021 0 : struct tevent_req *req =
13022 0 : tevent_req_callback_data(subreq,
13023 : struct tevent_req);
13024 : NTSTATUS status;
13025 :
13026 0 : status = dcerpc_binding_handle_call_recv(subreq);
13027 0 : TALLOC_FREE(subreq);
13028 0 : if (tevent_req_nterror(req, status)) {
13029 0 : return;
13030 : }
13031 :
13032 0 : tevent_req_done(req);
13033 : }
13034 :
13035 0 : NTSTATUS dcerpc_clusapi_AddNotifyCluster_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
13036 : {
13037 0 : struct dcerpc_clusapi_AddNotifyCluster_r_state *state =
13038 0 : tevent_req_data(req,
13039 : struct dcerpc_clusapi_AddNotifyCluster_r_state);
13040 : NTSTATUS status;
13041 :
13042 0 : if (tevent_req_is_nterror(req, &status)) {
13043 0 : tevent_req_received(req);
13044 0 : return status;
13045 : }
13046 :
13047 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13048 :
13049 0 : tevent_req_received(req);
13050 0 : return NT_STATUS_OK;
13051 : }
13052 :
13053 0 : NTSTATUS dcerpc_clusapi_AddNotifyCluster_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyCluster *r)
13054 : {
13055 : NTSTATUS status;
13056 :
13057 0 : status = dcerpc_binding_handle_call(h,
13058 : NULL, &ndr_table_clusapi,
13059 : NDR_CLUSAPI_ADDNOTIFYCLUSTER, mem_ctx, r);
13060 :
13061 0 : return status;
13062 : }
13063 :
13064 : struct dcerpc_clusapi_AddNotifyCluster_state {
13065 : struct clusapi_AddNotifyCluster orig;
13066 : struct clusapi_AddNotifyCluster tmp;
13067 : TALLOC_CTX *out_mem_ctx;
13068 : };
13069 :
13070 : static void dcerpc_clusapi_AddNotifyCluster_done(struct tevent_req *subreq);
13071 :
13072 0 : struct tevent_req *dcerpc_clusapi_AddNotifyCluster_send(TALLOC_CTX *mem_ctx,
13073 : struct tevent_context *ev,
13074 : struct dcerpc_binding_handle *h,
13075 : struct policy_handle _hNotify /* [in] */,
13076 : struct policy_handle _hCluster /* [in] */,
13077 : uint32_t _dwFilter /* [in] */,
13078 : uint32_t _dwNotifyKey /* [in] */,
13079 : WERROR *_rpc_status /* [out] [ref] */)
13080 : {
13081 : struct tevent_req *req;
13082 : struct dcerpc_clusapi_AddNotifyCluster_state *state;
13083 : struct tevent_req *subreq;
13084 :
13085 0 : req = tevent_req_create(mem_ctx, &state,
13086 : struct dcerpc_clusapi_AddNotifyCluster_state);
13087 0 : if (req == NULL) {
13088 0 : return NULL;
13089 : }
13090 0 : state->out_mem_ctx = NULL;
13091 :
13092 : /* In parameters */
13093 0 : state->orig.in.hNotify = _hNotify;
13094 0 : state->orig.in.hCluster = _hCluster;
13095 0 : state->orig.in.dwFilter = _dwFilter;
13096 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
13097 :
13098 : /* Out parameters */
13099 0 : state->orig.out.rpc_status = _rpc_status;
13100 :
13101 : /* Result */
13102 0 : NDR_ZERO_STRUCT(state->orig.out.result);
13103 :
13104 0 : state->out_mem_ctx = talloc_named_const(state, 0,
13105 : "dcerpc_clusapi_AddNotifyCluster_out_memory");
13106 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13107 0 : return tevent_req_post(req, ev);
13108 : }
13109 :
13110 : /* make a temporary copy, that we pass to the dispatch function */
13111 0 : state->tmp = state->orig;
13112 :
13113 0 : subreq = dcerpc_clusapi_AddNotifyCluster_r_send(state, ev, h, &state->tmp);
13114 0 : if (tevent_req_nomem(subreq, req)) {
13115 0 : return tevent_req_post(req, ev);
13116 : }
13117 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyCluster_done, req);
13118 0 : return req;
13119 : }
13120 :
13121 0 : static void dcerpc_clusapi_AddNotifyCluster_done(struct tevent_req *subreq)
13122 : {
13123 0 : struct tevent_req *req = tevent_req_callback_data(
13124 : subreq, struct tevent_req);
13125 0 : struct dcerpc_clusapi_AddNotifyCluster_state *state = tevent_req_data(
13126 : req, struct dcerpc_clusapi_AddNotifyCluster_state);
13127 : NTSTATUS status;
13128 : TALLOC_CTX *mem_ctx;
13129 :
13130 0 : if (state->out_mem_ctx) {
13131 0 : mem_ctx = state->out_mem_ctx;
13132 : } else {
13133 0 : mem_ctx = state;
13134 : }
13135 :
13136 0 : status = dcerpc_clusapi_AddNotifyCluster_r_recv(subreq, mem_ctx);
13137 0 : TALLOC_FREE(subreq);
13138 0 : if (tevent_req_nterror(req, status)) {
13139 0 : return;
13140 : }
13141 :
13142 : /* Copy out parameters */
13143 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
13144 :
13145 : /* Copy result */
13146 0 : state->orig.out.result = state->tmp.out.result;
13147 :
13148 : /* Reset temporary structure */
13149 0 : NDR_ZERO_STRUCT(state->tmp);
13150 :
13151 0 : tevent_req_done(req);
13152 : }
13153 :
13154 0 : NTSTATUS dcerpc_clusapi_AddNotifyCluster_recv(struct tevent_req *req,
13155 : TALLOC_CTX *mem_ctx,
13156 : WERROR *result)
13157 : {
13158 0 : struct dcerpc_clusapi_AddNotifyCluster_state *state = tevent_req_data(
13159 : req, struct dcerpc_clusapi_AddNotifyCluster_state);
13160 : NTSTATUS status;
13161 :
13162 0 : if (tevent_req_is_nterror(req, &status)) {
13163 0 : tevent_req_received(req);
13164 0 : return status;
13165 : }
13166 :
13167 : /* Steal possible out parameters to the callers context */
13168 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13169 :
13170 : /* Return result */
13171 0 : *result = state->orig.out.result;
13172 :
13173 0 : tevent_req_received(req);
13174 0 : return NT_STATUS_OK;
13175 : }
13176 :
13177 0 : NTSTATUS dcerpc_clusapi_AddNotifyCluster(struct dcerpc_binding_handle *h,
13178 : TALLOC_CTX *mem_ctx,
13179 : struct policy_handle _hNotify /* [in] */,
13180 : struct policy_handle _hCluster /* [in] */,
13181 : uint32_t _dwFilter /* [in] */,
13182 : uint32_t _dwNotifyKey /* [in] */,
13183 : WERROR *_rpc_status /* [out] [ref] */,
13184 : WERROR *result)
13185 : {
13186 : struct clusapi_AddNotifyCluster r;
13187 : NTSTATUS status;
13188 :
13189 : /* In parameters */
13190 0 : r.in.hNotify = _hNotify;
13191 0 : r.in.hCluster = _hCluster;
13192 0 : r.in.dwFilter = _dwFilter;
13193 0 : r.in.dwNotifyKey = _dwNotifyKey;
13194 :
13195 : /* Out parameters */
13196 0 : r.out.rpc_status = _rpc_status;
13197 :
13198 : /* Result */
13199 0 : NDR_ZERO_STRUCT(r.out.result);
13200 :
13201 0 : status = dcerpc_clusapi_AddNotifyCluster_r(h, mem_ctx, &r);
13202 0 : if (!NT_STATUS_IS_OK(status)) {
13203 0 : return status;
13204 : }
13205 :
13206 : /* Return variables */
13207 0 : *_rpc_status = *r.out.rpc_status;
13208 :
13209 : /* Return result */
13210 0 : *result = r.out.result;
13211 :
13212 0 : return NT_STATUS_OK;
13213 : }
13214 :
13215 : struct dcerpc_clusapi_AddNotifyNode_r_state {
13216 : TALLOC_CTX *out_mem_ctx;
13217 : };
13218 :
13219 : static void dcerpc_clusapi_AddNotifyNode_r_done(struct tevent_req *subreq);
13220 :
13221 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNode_r_send(TALLOC_CTX *mem_ctx,
13222 : struct tevent_context *ev,
13223 : struct dcerpc_binding_handle *h,
13224 : struct clusapi_AddNotifyNode *r)
13225 : {
13226 : struct tevent_req *req;
13227 : struct dcerpc_clusapi_AddNotifyNode_r_state *state;
13228 : struct tevent_req *subreq;
13229 :
13230 0 : req = tevent_req_create(mem_ctx, &state,
13231 : struct dcerpc_clusapi_AddNotifyNode_r_state);
13232 0 : if (req == NULL) {
13233 0 : return NULL;
13234 : }
13235 :
13236 0 : state->out_mem_ctx = talloc_new(state);
13237 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13238 0 : return tevent_req_post(req, ev);
13239 : }
13240 :
13241 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
13242 : NULL, &ndr_table_clusapi,
13243 0 : NDR_CLUSAPI_ADDNOTIFYNODE, state->out_mem_ctx, r);
13244 0 : if (tevent_req_nomem(subreq, req)) {
13245 0 : return tevent_req_post(req, ev);
13246 : }
13247 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNode_r_done, req);
13248 :
13249 0 : return req;
13250 : }
13251 :
13252 0 : static void dcerpc_clusapi_AddNotifyNode_r_done(struct tevent_req *subreq)
13253 : {
13254 0 : struct tevent_req *req =
13255 0 : tevent_req_callback_data(subreq,
13256 : struct tevent_req);
13257 : NTSTATUS status;
13258 :
13259 0 : status = dcerpc_binding_handle_call_recv(subreq);
13260 0 : TALLOC_FREE(subreq);
13261 0 : if (tevent_req_nterror(req, status)) {
13262 0 : return;
13263 : }
13264 :
13265 0 : tevent_req_done(req);
13266 : }
13267 :
13268 0 : NTSTATUS dcerpc_clusapi_AddNotifyNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
13269 : {
13270 0 : struct dcerpc_clusapi_AddNotifyNode_r_state *state =
13271 0 : tevent_req_data(req,
13272 : struct dcerpc_clusapi_AddNotifyNode_r_state);
13273 : NTSTATUS status;
13274 :
13275 0 : if (tevent_req_is_nterror(req, &status)) {
13276 0 : tevent_req_received(req);
13277 0 : return status;
13278 : }
13279 :
13280 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13281 :
13282 0 : tevent_req_received(req);
13283 0 : return NT_STATUS_OK;
13284 : }
13285 :
13286 0 : NTSTATUS dcerpc_clusapi_AddNotifyNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyNode *r)
13287 : {
13288 : NTSTATUS status;
13289 :
13290 0 : status = dcerpc_binding_handle_call(h,
13291 : NULL, &ndr_table_clusapi,
13292 : NDR_CLUSAPI_ADDNOTIFYNODE, mem_ctx, r);
13293 :
13294 0 : return status;
13295 : }
13296 :
13297 : struct dcerpc_clusapi_AddNotifyNode_state {
13298 : struct clusapi_AddNotifyNode orig;
13299 : struct clusapi_AddNotifyNode tmp;
13300 : TALLOC_CTX *out_mem_ctx;
13301 : };
13302 :
13303 : static void dcerpc_clusapi_AddNotifyNode_done(struct tevent_req *subreq);
13304 :
13305 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNode_send(TALLOC_CTX *mem_ctx,
13306 : struct tevent_context *ev,
13307 : struct dcerpc_binding_handle *h,
13308 : struct policy_handle _hNotify /* [in] */,
13309 : struct policy_handle _hNode /* [in] */,
13310 : uint32_t _dwFilter /* [in] */,
13311 : uint32_t _dwNotifyKey /* [in] */,
13312 : uint32_t *_dwStateSequence /* [out] [ref] */,
13313 : WERROR *_rpc_status /* [out] [ref] */)
13314 : {
13315 : struct tevent_req *req;
13316 : struct dcerpc_clusapi_AddNotifyNode_state *state;
13317 : struct tevent_req *subreq;
13318 :
13319 0 : req = tevent_req_create(mem_ctx, &state,
13320 : struct dcerpc_clusapi_AddNotifyNode_state);
13321 0 : if (req == NULL) {
13322 0 : return NULL;
13323 : }
13324 0 : state->out_mem_ctx = NULL;
13325 :
13326 : /* In parameters */
13327 0 : state->orig.in.hNotify = _hNotify;
13328 0 : state->orig.in.hNode = _hNode;
13329 0 : state->orig.in.dwFilter = _dwFilter;
13330 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
13331 :
13332 : /* Out parameters */
13333 0 : state->orig.out.dwStateSequence = _dwStateSequence;
13334 0 : state->orig.out.rpc_status = _rpc_status;
13335 :
13336 : /* Result */
13337 0 : NDR_ZERO_STRUCT(state->orig.out.result);
13338 :
13339 0 : state->out_mem_ctx = talloc_named_const(state, 0,
13340 : "dcerpc_clusapi_AddNotifyNode_out_memory");
13341 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13342 0 : return tevent_req_post(req, ev);
13343 : }
13344 :
13345 : /* make a temporary copy, that we pass to the dispatch function */
13346 0 : state->tmp = state->orig;
13347 :
13348 0 : subreq = dcerpc_clusapi_AddNotifyNode_r_send(state, ev, h, &state->tmp);
13349 0 : if (tevent_req_nomem(subreq, req)) {
13350 0 : return tevent_req_post(req, ev);
13351 : }
13352 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNode_done, req);
13353 0 : return req;
13354 : }
13355 :
13356 0 : static void dcerpc_clusapi_AddNotifyNode_done(struct tevent_req *subreq)
13357 : {
13358 0 : struct tevent_req *req = tevent_req_callback_data(
13359 : subreq, struct tevent_req);
13360 0 : struct dcerpc_clusapi_AddNotifyNode_state *state = tevent_req_data(
13361 : req, struct dcerpc_clusapi_AddNotifyNode_state);
13362 : NTSTATUS status;
13363 : TALLOC_CTX *mem_ctx;
13364 :
13365 0 : if (state->out_mem_ctx) {
13366 0 : mem_ctx = state->out_mem_ctx;
13367 : } else {
13368 0 : mem_ctx = state;
13369 : }
13370 :
13371 0 : status = dcerpc_clusapi_AddNotifyNode_r_recv(subreq, mem_ctx);
13372 0 : TALLOC_FREE(subreq);
13373 0 : if (tevent_req_nterror(req, status)) {
13374 0 : return;
13375 : }
13376 :
13377 : /* Copy out parameters */
13378 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
13379 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
13380 :
13381 : /* Copy result */
13382 0 : state->orig.out.result = state->tmp.out.result;
13383 :
13384 : /* Reset temporary structure */
13385 0 : NDR_ZERO_STRUCT(state->tmp);
13386 :
13387 0 : tevent_req_done(req);
13388 : }
13389 :
13390 0 : NTSTATUS dcerpc_clusapi_AddNotifyNode_recv(struct tevent_req *req,
13391 : TALLOC_CTX *mem_ctx,
13392 : WERROR *result)
13393 : {
13394 0 : struct dcerpc_clusapi_AddNotifyNode_state *state = tevent_req_data(
13395 : req, struct dcerpc_clusapi_AddNotifyNode_state);
13396 : NTSTATUS status;
13397 :
13398 0 : if (tevent_req_is_nterror(req, &status)) {
13399 0 : tevent_req_received(req);
13400 0 : return status;
13401 : }
13402 :
13403 : /* Steal possible out parameters to the callers context */
13404 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13405 :
13406 : /* Return result */
13407 0 : *result = state->orig.out.result;
13408 :
13409 0 : tevent_req_received(req);
13410 0 : return NT_STATUS_OK;
13411 : }
13412 :
13413 0 : NTSTATUS dcerpc_clusapi_AddNotifyNode(struct dcerpc_binding_handle *h,
13414 : TALLOC_CTX *mem_ctx,
13415 : struct policy_handle _hNotify /* [in] */,
13416 : struct policy_handle _hNode /* [in] */,
13417 : uint32_t _dwFilter /* [in] */,
13418 : uint32_t _dwNotifyKey /* [in] */,
13419 : uint32_t *_dwStateSequence /* [out] [ref] */,
13420 : WERROR *_rpc_status /* [out] [ref] */,
13421 : WERROR *result)
13422 : {
13423 : struct clusapi_AddNotifyNode r;
13424 : NTSTATUS status;
13425 :
13426 : /* In parameters */
13427 0 : r.in.hNotify = _hNotify;
13428 0 : r.in.hNode = _hNode;
13429 0 : r.in.dwFilter = _dwFilter;
13430 0 : r.in.dwNotifyKey = _dwNotifyKey;
13431 :
13432 : /* Out parameters */
13433 0 : r.out.dwStateSequence = _dwStateSequence;
13434 0 : r.out.rpc_status = _rpc_status;
13435 :
13436 : /* Result */
13437 0 : NDR_ZERO_STRUCT(r.out.result);
13438 :
13439 0 : status = dcerpc_clusapi_AddNotifyNode_r(h, mem_ctx, &r);
13440 0 : if (!NT_STATUS_IS_OK(status)) {
13441 0 : return status;
13442 : }
13443 :
13444 : /* Return variables */
13445 0 : *_dwStateSequence = *r.out.dwStateSequence;
13446 0 : *_rpc_status = *r.out.rpc_status;
13447 :
13448 : /* Return result */
13449 0 : *result = r.out.result;
13450 :
13451 0 : return NT_STATUS_OK;
13452 : }
13453 :
13454 : struct dcerpc_clusapi_AddNotifyGroup_r_state {
13455 : TALLOC_CTX *out_mem_ctx;
13456 : };
13457 :
13458 : static void dcerpc_clusapi_AddNotifyGroup_r_done(struct tevent_req *subreq);
13459 :
13460 0 : struct tevent_req *dcerpc_clusapi_AddNotifyGroup_r_send(TALLOC_CTX *mem_ctx,
13461 : struct tevent_context *ev,
13462 : struct dcerpc_binding_handle *h,
13463 : struct clusapi_AddNotifyGroup *r)
13464 : {
13465 : struct tevent_req *req;
13466 : struct dcerpc_clusapi_AddNotifyGroup_r_state *state;
13467 : struct tevent_req *subreq;
13468 :
13469 0 : req = tevent_req_create(mem_ctx, &state,
13470 : struct dcerpc_clusapi_AddNotifyGroup_r_state);
13471 0 : if (req == NULL) {
13472 0 : return NULL;
13473 : }
13474 :
13475 0 : state->out_mem_ctx = talloc_new(state);
13476 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13477 0 : return tevent_req_post(req, ev);
13478 : }
13479 :
13480 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
13481 : NULL, &ndr_table_clusapi,
13482 0 : NDR_CLUSAPI_ADDNOTIFYGROUP, state->out_mem_ctx, r);
13483 0 : if (tevent_req_nomem(subreq, req)) {
13484 0 : return tevent_req_post(req, ev);
13485 : }
13486 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyGroup_r_done, req);
13487 :
13488 0 : return req;
13489 : }
13490 :
13491 0 : static void dcerpc_clusapi_AddNotifyGroup_r_done(struct tevent_req *subreq)
13492 : {
13493 0 : struct tevent_req *req =
13494 0 : tevent_req_callback_data(subreq,
13495 : struct tevent_req);
13496 : NTSTATUS status;
13497 :
13498 0 : status = dcerpc_binding_handle_call_recv(subreq);
13499 0 : TALLOC_FREE(subreq);
13500 0 : if (tevent_req_nterror(req, status)) {
13501 0 : return;
13502 : }
13503 :
13504 0 : tevent_req_done(req);
13505 : }
13506 :
13507 0 : NTSTATUS dcerpc_clusapi_AddNotifyGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
13508 : {
13509 0 : struct dcerpc_clusapi_AddNotifyGroup_r_state *state =
13510 0 : tevent_req_data(req,
13511 : struct dcerpc_clusapi_AddNotifyGroup_r_state);
13512 : NTSTATUS status;
13513 :
13514 0 : if (tevent_req_is_nterror(req, &status)) {
13515 0 : tevent_req_received(req);
13516 0 : return status;
13517 : }
13518 :
13519 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13520 :
13521 0 : tevent_req_received(req);
13522 0 : return NT_STATUS_OK;
13523 : }
13524 :
13525 0 : NTSTATUS dcerpc_clusapi_AddNotifyGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyGroup *r)
13526 : {
13527 : NTSTATUS status;
13528 :
13529 0 : status = dcerpc_binding_handle_call(h,
13530 : NULL, &ndr_table_clusapi,
13531 : NDR_CLUSAPI_ADDNOTIFYGROUP, mem_ctx, r);
13532 :
13533 0 : return status;
13534 : }
13535 :
13536 : struct dcerpc_clusapi_AddNotifyGroup_state {
13537 : struct clusapi_AddNotifyGroup orig;
13538 : struct clusapi_AddNotifyGroup tmp;
13539 : TALLOC_CTX *out_mem_ctx;
13540 : };
13541 :
13542 : static void dcerpc_clusapi_AddNotifyGroup_done(struct tevent_req *subreq);
13543 :
13544 0 : struct tevent_req *dcerpc_clusapi_AddNotifyGroup_send(TALLOC_CTX *mem_ctx,
13545 : struct tevent_context *ev,
13546 : struct dcerpc_binding_handle *h,
13547 : struct policy_handle _hNotify /* [in] */,
13548 : struct policy_handle _hGroup /* [in] */,
13549 : uint32_t _dwFilter /* [in] */,
13550 : uint32_t _dwNotifyKey /* [in] */,
13551 : uint32_t *_dwStateSequence /* [out] [ref] */,
13552 : WERROR *_rpc_status /* [out] [ref] */)
13553 : {
13554 : struct tevent_req *req;
13555 : struct dcerpc_clusapi_AddNotifyGroup_state *state;
13556 : struct tevent_req *subreq;
13557 :
13558 0 : req = tevent_req_create(mem_ctx, &state,
13559 : struct dcerpc_clusapi_AddNotifyGroup_state);
13560 0 : if (req == NULL) {
13561 0 : return NULL;
13562 : }
13563 0 : state->out_mem_ctx = NULL;
13564 :
13565 : /* In parameters */
13566 0 : state->orig.in.hNotify = _hNotify;
13567 0 : state->orig.in.hGroup = _hGroup;
13568 0 : state->orig.in.dwFilter = _dwFilter;
13569 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
13570 :
13571 : /* Out parameters */
13572 0 : state->orig.out.dwStateSequence = _dwStateSequence;
13573 0 : state->orig.out.rpc_status = _rpc_status;
13574 :
13575 : /* Result */
13576 0 : NDR_ZERO_STRUCT(state->orig.out.result);
13577 :
13578 0 : state->out_mem_ctx = talloc_named_const(state, 0,
13579 : "dcerpc_clusapi_AddNotifyGroup_out_memory");
13580 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13581 0 : return tevent_req_post(req, ev);
13582 : }
13583 :
13584 : /* make a temporary copy, that we pass to the dispatch function */
13585 0 : state->tmp = state->orig;
13586 :
13587 0 : subreq = dcerpc_clusapi_AddNotifyGroup_r_send(state, ev, h, &state->tmp);
13588 0 : if (tevent_req_nomem(subreq, req)) {
13589 0 : return tevent_req_post(req, ev);
13590 : }
13591 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyGroup_done, req);
13592 0 : return req;
13593 : }
13594 :
13595 0 : static void dcerpc_clusapi_AddNotifyGroup_done(struct tevent_req *subreq)
13596 : {
13597 0 : struct tevent_req *req = tevent_req_callback_data(
13598 : subreq, struct tevent_req);
13599 0 : struct dcerpc_clusapi_AddNotifyGroup_state *state = tevent_req_data(
13600 : req, struct dcerpc_clusapi_AddNotifyGroup_state);
13601 : NTSTATUS status;
13602 : TALLOC_CTX *mem_ctx;
13603 :
13604 0 : if (state->out_mem_ctx) {
13605 0 : mem_ctx = state->out_mem_ctx;
13606 : } else {
13607 0 : mem_ctx = state;
13608 : }
13609 :
13610 0 : status = dcerpc_clusapi_AddNotifyGroup_r_recv(subreq, mem_ctx);
13611 0 : TALLOC_FREE(subreq);
13612 0 : if (tevent_req_nterror(req, status)) {
13613 0 : return;
13614 : }
13615 :
13616 : /* Copy out parameters */
13617 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
13618 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
13619 :
13620 : /* Copy result */
13621 0 : state->orig.out.result = state->tmp.out.result;
13622 :
13623 : /* Reset temporary structure */
13624 0 : NDR_ZERO_STRUCT(state->tmp);
13625 :
13626 0 : tevent_req_done(req);
13627 : }
13628 :
13629 0 : NTSTATUS dcerpc_clusapi_AddNotifyGroup_recv(struct tevent_req *req,
13630 : TALLOC_CTX *mem_ctx,
13631 : WERROR *result)
13632 : {
13633 0 : struct dcerpc_clusapi_AddNotifyGroup_state *state = tevent_req_data(
13634 : req, struct dcerpc_clusapi_AddNotifyGroup_state);
13635 : NTSTATUS status;
13636 :
13637 0 : if (tevent_req_is_nterror(req, &status)) {
13638 0 : tevent_req_received(req);
13639 0 : return status;
13640 : }
13641 :
13642 : /* Steal possible out parameters to the callers context */
13643 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13644 :
13645 : /* Return result */
13646 0 : *result = state->orig.out.result;
13647 :
13648 0 : tevent_req_received(req);
13649 0 : return NT_STATUS_OK;
13650 : }
13651 :
13652 0 : NTSTATUS dcerpc_clusapi_AddNotifyGroup(struct dcerpc_binding_handle *h,
13653 : TALLOC_CTX *mem_ctx,
13654 : struct policy_handle _hNotify /* [in] */,
13655 : struct policy_handle _hGroup /* [in] */,
13656 : uint32_t _dwFilter /* [in] */,
13657 : uint32_t _dwNotifyKey /* [in] */,
13658 : uint32_t *_dwStateSequence /* [out] [ref] */,
13659 : WERROR *_rpc_status /* [out] [ref] */,
13660 : WERROR *result)
13661 : {
13662 : struct clusapi_AddNotifyGroup r;
13663 : NTSTATUS status;
13664 :
13665 : /* In parameters */
13666 0 : r.in.hNotify = _hNotify;
13667 0 : r.in.hGroup = _hGroup;
13668 0 : r.in.dwFilter = _dwFilter;
13669 0 : r.in.dwNotifyKey = _dwNotifyKey;
13670 :
13671 : /* Out parameters */
13672 0 : r.out.dwStateSequence = _dwStateSequence;
13673 0 : r.out.rpc_status = _rpc_status;
13674 :
13675 : /* Result */
13676 0 : NDR_ZERO_STRUCT(r.out.result);
13677 :
13678 0 : status = dcerpc_clusapi_AddNotifyGroup_r(h, mem_ctx, &r);
13679 0 : if (!NT_STATUS_IS_OK(status)) {
13680 0 : return status;
13681 : }
13682 :
13683 : /* Return variables */
13684 0 : *_dwStateSequence = *r.out.dwStateSequence;
13685 0 : *_rpc_status = *r.out.rpc_status;
13686 :
13687 : /* Return result */
13688 0 : *result = r.out.result;
13689 :
13690 0 : return NT_STATUS_OK;
13691 : }
13692 :
13693 : struct dcerpc_clusapi_AddNotifyResource_r_state {
13694 : TALLOC_CTX *out_mem_ctx;
13695 : };
13696 :
13697 : static void dcerpc_clusapi_AddNotifyResource_r_done(struct tevent_req *subreq);
13698 :
13699 0 : struct tevent_req *dcerpc_clusapi_AddNotifyResource_r_send(TALLOC_CTX *mem_ctx,
13700 : struct tevent_context *ev,
13701 : struct dcerpc_binding_handle *h,
13702 : struct clusapi_AddNotifyResource *r)
13703 : {
13704 : struct tevent_req *req;
13705 : struct dcerpc_clusapi_AddNotifyResource_r_state *state;
13706 : struct tevent_req *subreq;
13707 :
13708 0 : req = tevent_req_create(mem_ctx, &state,
13709 : struct dcerpc_clusapi_AddNotifyResource_r_state);
13710 0 : if (req == NULL) {
13711 0 : return NULL;
13712 : }
13713 :
13714 0 : state->out_mem_ctx = talloc_new(state);
13715 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13716 0 : return tevent_req_post(req, ev);
13717 : }
13718 :
13719 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
13720 : NULL, &ndr_table_clusapi,
13721 0 : NDR_CLUSAPI_ADDNOTIFYRESOURCE, state->out_mem_ctx, r);
13722 0 : if (tevent_req_nomem(subreq, req)) {
13723 0 : return tevent_req_post(req, ev);
13724 : }
13725 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyResource_r_done, req);
13726 :
13727 0 : return req;
13728 : }
13729 :
13730 0 : static void dcerpc_clusapi_AddNotifyResource_r_done(struct tevent_req *subreq)
13731 : {
13732 0 : struct tevent_req *req =
13733 0 : tevent_req_callback_data(subreq,
13734 : struct tevent_req);
13735 : NTSTATUS status;
13736 :
13737 0 : status = dcerpc_binding_handle_call_recv(subreq);
13738 0 : TALLOC_FREE(subreq);
13739 0 : if (tevent_req_nterror(req, status)) {
13740 0 : return;
13741 : }
13742 :
13743 0 : tevent_req_done(req);
13744 : }
13745 :
13746 0 : NTSTATUS dcerpc_clusapi_AddNotifyResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
13747 : {
13748 0 : struct dcerpc_clusapi_AddNotifyResource_r_state *state =
13749 0 : tevent_req_data(req,
13750 : struct dcerpc_clusapi_AddNotifyResource_r_state);
13751 : NTSTATUS status;
13752 :
13753 0 : if (tevent_req_is_nterror(req, &status)) {
13754 0 : tevent_req_received(req);
13755 0 : return status;
13756 : }
13757 :
13758 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13759 :
13760 0 : tevent_req_received(req);
13761 0 : return NT_STATUS_OK;
13762 : }
13763 :
13764 0 : NTSTATUS dcerpc_clusapi_AddNotifyResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyResource *r)
13765 : {
13766 : NTSTATUS status;
13767 :
13768 0 : status = dcerpc_binding_handle_call(h,
13769 : NULL, &ndr_table_clusapi,
13770 : NDR_CLUSAPI_ADDNOTIFYRESOURCE, mem_ctx, r);
13771 :
13772 0 : return status;
13773 : }
13774 :
13775 : struct dcerpc_clusapi_AddNotifyResource_state {
13776 : struct clusapi_AddNotifyResource orig;
13777 : struct clusapi_AddNotifyResource tmp;
13778 : TALLOC_CTX *out_mem_ctx;
13779 : };
13780 :
13781 : static void dcerpc_clusapi_AddNotifyResource_done(struct tevent_req *subreq);
13782 :
13783 0 : struct tevent_req *dcerpc_clusapi_AddNotifyResource_send(TALLOC_CTX *mem_ctx,
13784 : struct tevent_context *ev,
13785 : struct dcerpc_binding_handle *h,
13786 : struct policy_handle _hNotify /* [in] */,
13787 : struct policy_handle _hResource /* [in] */,
13788 : uint32_t _dwFilter /* [in] */,
13789 : uint32_t _dwNotifyKey /* [in] */,
13790 : uint32_t *_dwStateSequence /* [out] [ref] */,
13791 : WERROR *_rpc_status /* [out] [ref] */)
13792 : {
13793 : struct tevent_req *req;
13794 : struct dcerpc_clusapi_AddNotifyResource_state *state;
13795 : struct tevent_req *subreq;
13796 :
13797 0 : req = tevent_req_create(mem_ctx, &state,
13798 : struct dcerpc_clusapi_AddNotifyResource_state);
13799 0 : if (req == NULL) {
13800 0 : return NULL;
13801 : }
13802 0 : state->out_mem_ctx = NULL;
13803 :
13804 : /* In parameters */
13805 0 : state->orig.in.hNotify = _hNotify;
13806 0 : state->orig.in.hResource = _hResource;
13807 0 : state->orig.in.dwFilter = _dwFilter;
13808 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
13809 :
13810 : /* Out parameters */
13811 0 : state->orig.out.dwStateSequence = _dwStateSequence;
13812 0 : state->orig.out.rpc_status = _rpc_status;
13813 :
13814 : /* Result */
13815 0 : NDR_ZERO_STRUCT(state->orig.out.result);
13816 :
13817 0 : state->out_mem_ctx = talloc_named_const(state, 0,
13818 : "dcerpc_clusapi_AddNotifyResource_out_memory");
13819 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13820 0 : return tevent_req_post(req, ev);
13821 : }
13822 :
13823 : /* make a temporary copy, that we pass to the dispatch function */
13824 0 : state->tmp = state->orig;
13825 :
13826 0 : subreq = dcerpc_clusapi_AddNotifyResource_r_send(state, ev, h, &state->tmp);
13827 0 : if (tevent_req_nomem(subreq, req)) {
13828 0 : return tevent_req_post(req, ev);
13829 : }
13830 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyResource_done, req);
13831 0 : return req;
13832 : }
13833 :
13834 0 : static void dcerpc_clusapi_AddNotifyResource_done(struct tevent_req *subreq)
13835 : {
13836 0 : struct tevent_req *req = tevent_req_callback_data(
13837 : subreq, struct tevent_req);
13838 0 : struct dcerpc_clusapi_AddNotifyResource_state *state = tevent_req_data(
13839 : req, struct dcerpc_clusapi_AddNotifyResource_state);
13840 : NTSTATUS status;
13841 : TALLOC_CTX *mem_ctx;
13842 :
13843 0 : if (state->out_mem_ctx) {
13844 0 : mem_ctx = state->out_mem_ctx;
13845 : } else {
13846 0 : mem_ctx = state;
13847 : }
13848 :
13849 0 : status = dcerpc_clusapi_AddNotifyResource_r_recv(subreq, mem_ctx);
13850 0 : TALLOC_FREE(subreq);
13851 0 : if (tevent_req_nterror(req, status)) {
13852 0 : return;
13853 : }
13854 :
13855 : /* Copy out parameters */
13856 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
13857 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
13858 :
13859 : /* Copy result */
13860 0 : state->orig.out.result = state->tmp.out.result;
13861 :
13862 : /* Reset temporary structure */
13863 0 : NDR_ZERO_STRUCT(state->tmp);
13864 :
13865 0 : tevent_req_done(req);
13866 : }
13867 :
13868 0 : NTSTATUS dcerpc_clusapi_AddNotifyResource_recv(struct tevent_req *req,
13869 : TALLOC_CTX *mem_ctx,
13870 : WERROR *result)
13871 : {
13872 0 : struct dcerpc_clusapi_AddNotifyResource_state *state = tevent_req_data(
13873 : req, struct dcerpc_clusapi_AddNotifyResource_state);
13874 : NTSTATUS status;
13875 :
13876 0 : if (tevent_req_is_nterror(req, &status)) {
13877 0 : tevent_req_received(req);
13878 0 : return status;
13879 : }
13880 :
13881 : /* Steal possible out parameters to the callers context */
13882 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13883 :
13884 : /* Return result */
13885 0 : *result = state->orig.out.result;
13886 :
13887 0 : tevent_req_received(req);
13888 0 : return NT_STATUS_OK;
13889 : }
13890 :
13891 0 : NTSTATUS dcerpc_clusapi_AddNotifyResource(struct dcerpc_binding_handle *h,
13892 : TALLOC_CTX *mem_ctx,
13893 : struct policy_handle _hNotify /* [in] */,
13894 : struct policy_handle _hResource /* [in] */,
13895 : uint32_t _dwFilter /* [in] */,
13896 : uint32_t _dwNotifyKey /* [in] */,
13897 : uint32_t *_dwStateSequence /* [out] [ref] */,
13898 : WERROR *_rpc_status /* [out] [ref] */,
13899 : WERROR *result)
13900 : {
13901 : struct clusapi_AddNotifyResource r;
13902 : NTSTATUS status;
13903 :
13904 : /* In parameters */
13905 0 : r.in.hNotify = _hNotify;
13906 0 : r.in.hResource = _hResource;
13907 0 : r.in.dwFilter = _dwFilter;
13908 0 : r.in.dwNotifyKey = _dwNotifyKey;
13909 :
13910 : /* Out parameters */
13911 0 : r.out.dwStateSequence = _dwStateSequence;
13912 0 : r.out.rpc_status = _rpc_status;
13913 :
13914 : /* Result */
13915 0 : NDR_ZERO_STRUCT(r.out.result);
13916 :
13917 0 : status = dcerpc_clusapi_AddNotifyResource_r(h, mem_ctx, &r);
13918 0 : if (!NT_STATUS_IS_OK(status)) {
13919 0 : return status;
13920 : }
13921 :
13922 : /* Return variables */
13923 0 : *_dwStateSequence = *r.out.dwStateSequence;
13924 0 : *_rpc_status = *r.out.rpc_status;
13925 :
13926 : /* Return result */
13927 0 : *result = r.out.result;
13928 :
13929 0 : return NT_STATUS_OK;
13930 : }
13931 :
13932 : struct dcerpc_clusapi_AddNotifyKey_r_state {
13933 : TALLOC_CTX *out_mem_ctx;
13934 : };
13935 :
13936 : static void dcerpc_clusapi_AddNotifyKey_r_done(struct tevent_req *subreq);
13937 :
13938 0 : struct tevent_req *dcerpc_clusapi_AddNotifyKey_r_send(TALLOC_CTX *mem_ctx,
13939 : struct tevent_context *ev,
13940 : struct dcerpc_binding_handle *h,
13941 : struct clusapi_AddNotifyKey *r)
13942 : {
13943 : struct tevent_req *req;
13944 : struct dcerpc_clusapi_AddNotifyKey_r_state *state;
13945 : struct tevent_req *subreq;
13946 :
13947 0 : req = tevent_req_create(mem_ctx, &state,
13948 : struct dcerpc_clusapi_AddNotifyKey_r_state);
13949 0 : if (req == NULL) {
13950 0 : return NULL;
13951 : }
13952 :
13953 0 : state->out_mem_ctx = talloc_new(state);
13954 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
13955 0 : return tevent_req_post(req, ev);
13956 : }
13957 :
13958 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
13959 : NULL, &ndr_table_clusapi,
13960 0 : NDR_CLUSAPI_ADDNOTIFYKEY, state->out_mem_ctx, r);
13961 0 : if (tevent_req_nomem(subreq, req)) {
13962 0 : return tevent_req_post(req, ev);
13963 : }
13964 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyKey_r_done, req);
13965 :
13966 0 : return req;
13967 : }
13968 :
13969 0 : static void dcerpc_clusapi_AddNotifyKey_r_done(struct tevent_req *subreq)
13970 : {
13971 0 : struct tevent_req *req =
13972 0 : tevent_req_callback_data(subreq,
13973 : struct tevent_req);
13974 : NTSTATUS status;
13975 :
13976 0 : status = dcerpc_binding_handle_call_recv(subreq);
13977 0 : TALLOC_FREE(subreq);
13978 0 : if (tevent_req_nterror(req, status)) {
13979 0 : return;
13980 : }
13981 :
13982 0 : tevent_req_done(req);
13983 : }
13984 :
13985 0 : NTSTATUS dcerpc_clusapi_AddNotifyKey_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
13986 : {
13987 0 : struct dcerpc_clusapi_AddNotifyKey_r_state *state =
13988 0 : tevent_req_data(req,
13989 : struct dcerpc_clusapi_AddNotifyKey_r_state);
13990 : NTSTATUS status;
13991 :
13992 0 : if (tevent_req_is_nterror(req, &status)) {
13993 0 : tevent_req_received(req);
13994 0 : return status;
13995 : }
13996 :
13997 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
13998 :
13999 0 : tevent_req_received(req);
14000 0 : return NT_STATUS_OK;
14001 : }
14002 :
14003 0 : NTSTATUS dcerpc_clusapi_AddNotifyKey_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyKey *r)
14004 : {
14005 : NTSTATUS status;
14006 :
14007 0 : status = dcerpc_binding_handle_call(h,
14008 : NULL, &ndr_table_clusapi,
14009 : NDR_CLUSAPI_ADDNOTIFYKEY, mem_ctx, r);
14010 :
14011 0 : return status;
14012 : }
14013 :
14014 : struct dcerpc_clusapi_AddNotifyKey_state {
14015 : struct clusapi_AddNotifyKey orig;
14016 : struct clusapi_AddNotifyKey tmp;
14017 : TALLOC_CTX *out_mem_ctx;
14018 : };
14019 :
14020 : static void dcerpc_clusapi_AddNotifyKey_done(struct tevent_req *subreq);
14021 :
14022 0 : struct tevent_req *dcerpc_clusapi_AddNotifyKey_send(TALLOC_CTX *mem_ctx,
14023 : struct tevent_context *ev,
14024 : struct dcerpc_binding_handle *h,
14025 : struct policy_handle _hNotify /* [in] */,
14026 : struct policy_handle _hKey /* [in] */,
14027 : uint32_t _dwNotifyKey /* [in] */,
14028 : uint32_t _Filter /* [in] */,
14029 : uint8_t _WatchSubTree /* [in] */,
14030 : WERROR *_rpc_status /* [out] [ref] */)
14031 : {
14032 : struct tevent_req *req;
14033 : struct dcerpc_clusapi_AddNotifyKey_state *state;
14034 : struct tevent_req *subreq;
14035 :
14036 0 : req = tevent_req_create(mem_ctx, &state,
14037 : struct dcerpc_clusapi_AddNotifyKey_state);
14038 0 : if (req == NULL) {
14039 0 : return NULL;
14040 : }
14041 0 : state->out_mem_ctx = NULL;
14042 :
14043 : /* In parameters */
14044 0 : state->orig.in.hNotify = _hNotify;
14045 0 : state->orig.in.hKey = _hKey;
14046 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
14047 0 : state->orig.in.Filter = _Filter;
14048 0 : state->orig.in.WatchSubTree = _WatchSubTree;
14049 :
14050 : /* Out parameters */
14051 0 : state->orig.out.rpc_status = _rpc_status;
14052 :
14053 : /* Result */
14054 0 : NDR_ZERO_STRUCT(state->orig.out.result);
14055 :
14056 0 : state->out_mem_ctx = talloc_named_const(state, 0,
14057 : "dcerpc_clusapi_AddNotifyKey_out_memory");
14058 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14059 0 : return tevent_req_post(req, ev);
14060 : }
14061 :
14062 : /* make a temporary copy, that we pass to the dispatch function */
14063 0 : state->tmp = state->orig;
14064 :
14065 0 : subreq = dcerpc_clusapi_AddNotifyKey_r_send(state, ev, h, &state->tmp);
14066 0 : if (tevent_req_nomem(subreq, req)) {
14067 0 : return tevent_req_post(req, ev);
14068 : }
14069 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyKey_done, req);
14070 0 : return req;
14071 : }
14072 :
14073 0 : static void dcerpc_clusapi_AddNotifyKey_done(struct tevent_req *subreq)
14074 : {
14075 0 : struct tevent_req *req = tevent_req_callback_data(
14076 : subreq, struct tevent_req);
14077 0 : struct dcerpc_clusapi_AddNotifyKey_state *state = tevent_req_data(
14078 : req, struct dcerpc_clusapi_AddNotifyKey_state);
14079 : NTSTATUS status;
14080 : TALLOC_CTX *mem_ctx;
14081 :
14082 0 : if (state->out_mem_ctx) {
14083 0 : mem_ctx = state->out_mem_ctx;
14084 : } else {
14085 0 : mem_ctx = state;
14086 : }
14087 :
14088 0 : status = dcerpc_clusapi_AddNotifyKey_r_recv(subreq, mem_ctx);
14089 0 : TALLOC_FREE(subreq);
14090 0 : if (tevent_req_nterror(req, status)) {
14091 0 : return;
14092 : }
14093 :
14094 : /* Copy out parameters */
14095 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
14096 :
14097 : /* Copy result */
14098 0 : state->orig.out.result = state->tmp.out.result;
14099 :
14100 : /* Reset temporary structure */
14101 0 : NDR_ZERO_STRUCT(state->tmp);
14102 :
14103 0 : tevent_req_done(req);
14104 : }
14105 :
14106 0 : NTSTATUS dcerpc_clusapi_AddNotifyKey_recv(struct tevent_req *req,
14107 : TALLOC_CTX *mem_ctx,
14108 : WERROR *result)
14109 : {
14110 0 : struct dcerpc_clusapi_AddNotifyKey_state *state = tevent_req_data(
14111 : req, struct dcerpc_clusapi_AddNotifyKey_state);
14112 : NTSTATUS status;
14113 :
14114 0 : if (tevent_req_is_nterror(req, &status)) {
14115 0 : tevent_req_received(req);
14116 0 : return status;
14117 : }
14118 :
14119 : /* Steal possible out parameters to the callers context */
14120 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14121 :
14122 : /* Return result */
14123 0 : *result = state->orig.out.result;
14124 :
14125 0 : tevent_req_received(req);
14126 0 : return NT_STATUS_OK;
14127 : }
14128 :
14129 0 : NTSTATUS dcerpc_clusapi_AddNotifyKey(struct dcerpc_binding_handle *h,
14130 : TALLOC_CTX *mem_ctx,
14131 : struct policy_handle _hNotify /* [in] */,
14132 : struct policy_handle _hKey /* [in] */,
14133 : uint32_t _dwNotifyKey /* [in] */,
14134 : uint32_t _Filter /* [in] */,
14135 : uint8_t _WatchSubTree /* [in] */,
14136 : WERROR *_rpc_status /* [out] [ref] */,
14137 : WERROR *result)
14138 : {
14139 : struct clusapi_AddNotifyKey r;
14140 : NTSTATUS status;
14141 :
14142 : /* In parameters */
14143 0 : r.in.hNotify = _hNotify;
14144 0 : r.in.hKey = _hKey;
14145 0 : r.in.dwNotifyKey = _dwNotifyKey;
14146 0 : r.in.Filter = _Filter;
14147 0 : r.in.WatchSubTree = _WatchSubTree;
14148 :
14149 : /* Out parameters */
14150 0 : r.out.rpc_status = _rpc_status;
14151 :
14152 : /* Result */
14153 0 : NDR_ZERO_STRUCT(r.out.result);
14154 :
14155 0 : status = dcerpc_clusapi_AddNotifyKey_r(h, mem_ctx, &r);
14156 0 : if (!NT_STATUS_IS_OK(status)) {
14157 0 : return status;
14158 : }
14159 :
14160 : /* Return variables */
14161 0 : *_rpc_status = *r.out.rpc_status;
14162 :
14163 : /* Return result */
14164 0 : *result = r.out.result;
14165 :
14166 0 : return NT_STATUS_OK;
14167 : }
14168 :
14169 : struct dcerpc_clusapi_ReAddNotifyNode_r_state {
14170 : TALLOC_CTX *out_mem_ctx;
14171 : };
14172 :
14173 : static void dcerpc_clusapi_ReAddNotifyNode_r_done(struct tevent_req *subreq);
14174 :
14175 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNode_r_send(TALLOC_CTX *mem_ctx,
14176 : struct tevent_context *ev,
14177 : struct dcerpc_binding_handle *h,
14178 : struct clusapi_ReAddNotifyNode *r)
14179 : {
14180 : struct tevent_req *req;
14181 : struct dcerpc_clusapi_ReAddNotifyNode_r_state *state;
14182 : struct tevent_req *subreq;
14183 :
14184 0 : req = tevent_req_create(mem_ctx, &state,
14185 : struct dcerpc_clusapi_ReAddNotifyNode_r_state);
14186 0 : if (req == NULL) {
14187 0 : return NULL;
14188 : }
14189 :
14190 0 : state->out_mem_ctx = talloc_new(state);
14191 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14192 0 : return tevent_req_post(req, ev);
14193 : }
14194 :
14195 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
14196 : NULL, &ndr_table_clusapi,
14197 0 : NDR_CLUSAPI_READDNOTIFYNODE, state->out_mem_ctx, r);
14198 0 : if (tevent_req_nomem(subreq, req)) {
14199 0 : return tevent_req_post(req, ev);
14200 : }
14201 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNode_r_done, req);
14202 :
14203 0 : return req;
14204 : }
14205 :
14206 0 : static void dcerpc_clusapi_ReAddNotifyNode_r_done(struct tevent_req *subreq)
14207 : {
14208 0 : struct tevent_req *req =
14209 0 : tevent_req_callback_data(subreq,
14210 : struct tevent_req);
14211 : NTSTATUS status;
14212 :
14213 0 : status = dcerpc_binding_handle_call_recv(subreq);
14214 0 : TALLOC_FREE(subreq);
14215 0 : if (tevent_req_nterror(req, status)) {
14216 0 : return;
14217 : }
14218 :
14219 0 : tevent_req_done(req);
14220 : }
14221 :
14222 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
14223 : {
14224 0 : struct dcerpc_clusapi_ReAddNotifyNode_r_state *state =
14225 0 : tevent_req_data(req,
14226 : struct dcerpc_clusapi_ReAddNotifyNode_r_state);
14227 : NTSTATUS status;
14228 :
14229 0 : if (tevent_req_is_nterror(req, &status)) {
14230 0 : tevent_req_received(req);
14231 0 : return status;
14232 : }
14233 :
14234 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14235 :
14236 0 : tevent_req_received(req);
14237 0 : return NT_STATUS_OK;
14238 : }
14239 :
14240 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ReAddNotifyNode *r)
14241 : {
14242 : NTSTATUS status;
14243 :
14244 0 : status = dcerpc_binding_handle_call(h,
14245 : NULL, &ndr_table_clusapi,
14246 : NDR_CLUSAPI_READDNOTIFYNODE, mem_ctx, r);
14247 :
14248 0 : return status;
14249 : }
14250 :
14251 : struct dcerpc_clusapi_ReAddNotifyNode_state {
14252 : struct clusapi_ReAddNotifyNode orig;
14253 : struct clusapi_ReAddNotifyNode tmp;
14254 : TALLOC_CTX *out_mem_ctx;
14255 : };
14256 :
14257 : static void dcerpc_clusapi_ReAddNotifyNode_done(struct tevent_req *subreq);
14258 :
14259 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNode_send(TALLOC_CTX *mem_ctx,
14260 : struct tevent_context *ev,
14261 : struct dcerpc_binding_handle *h,
14262 : struct policy_handle _hNotify /* [in] */,
14263 : struct policy_handle _hNode /* [in] */,
14264 : uint32_t _dwFilter /* [in] */,
14265 : uint32_t _dwNotifyKey /* [in] */,
14266 : uint32_t _StateSequence /* [in] */,
14267 : WERROR *_rpc_status /* [out] [ref] */)
14268 : {
14269 : struct tevent_req *req;
14270 : struct dcerpc_clusapi_ReAddNotifyNode_state *state;
14271 : struct tevent_req *subreq;
14272 :
14273 0 : req = tevent_req_create(mem_ctx, &state,
14274 : struct dcerpc_clusapi_ReAddNotifyNode_state);
14275 0 : if (req == NULL) {
14276 0 : return NULL;
14277 : }
14278 0 : state->out_mem_ctx = NULL;
14279 :
14280 : /* In parameters */
14281 0 : state->orig.in.hNotify = _hNotify;
14282 0 : state->orig.in.hNode = _hNode;
14283 0 : state->orig.in.dwFilter = _dwFilter;
14284 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
14285 0 : state->orig.in.StateSequence = _StateSequence;
14286 :
14287 : /* Out parameters */
14288 0 : state->orig.out.rpc_status = _rpc_status;
14289 :
14290 : /* Result */
14291 0 : NDR_ZERO_STRUCT(state->orig.out.result);
14292 :
14293 0 : state->out_mem_ctx = talloc_named_const(state, 0,
14294 : "dcerpc_clusapi_ReAddNotifyNode_out_memory");
14295 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14296 0 : return tevent_req_post(req, ev);
14297 : }
14298 :
14299 : /* make a temporary copy, that we pass to the dispatch function */
14300 0 : state->tmp = state->orig;
14301 :
14302 0 : subreq = dcerpc_clusapi_ReAddNotifyNode_r_send(state, ev, h, &state->tmp);
14303 0 : if (tevent_req_nomem(subreq, req)) {
14304 0 : return tevent_req_post(req, ev);
14305 : }
14306 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNode_done, req);
14307 0 : return req;
14308 : }
14309 :
14310 0 : static void dcerpc_clusapi_ReAddNotifyNode_done(struct tevent_req *subreq)
14311 : {
14312 0 : struct tevent_req *req = tevent_req_callback_data(
14313 : subreq, struct tevent_req);
14314 0 : struct dcerpc_clusapi_ReAddNotifyNode_state *state = tevent_req_data(
14315 : req, struct dcerpc_clusapi_ReAddNotifyNode_state);
14316 : NTSTATUS status;
14317 : TALLOC_CTX *mem_ctx;
14318 :
14319 0 : if (state->out_mem_ctx) {
14320 0 : mem_ctx = state->out_mem_ctx;
14321 : } else {
14322 0 : mem_ctx = state;
14323 : }
14324 :
14325 0 : status = dcerpc_clusapi_ReAddNotifyNode_r_recv(subreq, mem_ctx);
14326 0 : TALLOC_FREE(subreq);
14327 0 : if (tevent_req_nterror(req, status)) {
14328 0 : return;
14329 : }
14330 :
14331 : /* Copy out parameters */
14332 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
14333 :
14334 : /* Copy result */
14335 0 : state->orig.out.result = state->tmp.out.result;
14336 :
14337 : /* Reset temporary structure */
14338 0 : NDR_ZERO_STRUCT(state->tmp);
14339 :
14340 0 : tevent_req_done(req);
14341 : }
14342 :
14343 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNode_recv(struct tevent_req *req,
14344 : TALLOC_CTX *mem_ctx,
14345 : WERROR *result)
14346 : {
14347 0 : struct dcerpc_clusapi_ReAddNotifyNode_state *state = tevent_req_data(
14348 : req, struct dcerpc_clusapi_ReAddNotifyNode_state);
14349 : NTSTATUS status;
14350 :
14351 0 : if (tevent_req_is_nterror(req, &status)) {
14352 0 : tevent_req_received(req);
14353 0 : return status;
14354 : }
14355 :
14356 : /* Steal possible out parameters to the callers context */
14357 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14358 :
14359 : /* Return result */
14360 0 : *result = state->orig.out.result;
14361 :
14362 0 : tevent_req_received(req);
14363 0 : return NT_STATUS_OK;
14364 : }
14365 :
14366 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNode(struct dcerpc_binding_handle *h,
14367 : TALLOC_CTX *mem_ctx,
14368 : struct policy_handle _hNotify /* [in] */,
14369 : struct policy_handle _hNode /* [in] */,
14370 : uint32_t _dwFilter /* [in] */,
14371 : uint32_t _dwNotifyKey /* [in] */,
14372 : uint32_t _StateSequence /* [in] */,
14373 : WERROR *_rpc_status /* [out] [ref] */,
14374 : WERROR *result)
14375 : {
14376 : struct clusapi_ReAddNotifyNode r;
14377 : NTSTATUS status;
14378 :
14379 : /* In parameters */
14380 0 : r.in.hNotify = _hNotify;
14381 0 : r.in.hNode = _hNode;
14382 0 : r.in.dwFilter = _dwFilter;
14383 0 : r.in.dwNotifyKey = _dwNotifyKey;
14384 0 : r.in.StateSequence = _StateSequence;
14385 :
14386 : /* Out parameters */
14387 0 : r.out.rpc_status = _rpc_status;
14388 :
14389 : /* Result */
14390 0 : NDR_ZERO_STRUCT(r.out.result);
14391 :
14392 0 : status = dcerpc_clusapi_ReAddNotifyNode_r(h, mem_ctx, &r);
14393 0 : if (!NT_STATUS_IS_OK(status)) {
14394 0 : return status;
14395 : }
14396 :
14397 : /* Return variables */
14398 0 : *_rpc_status = *r.out.rpc_status;
14399 :
14400 : /* Return result */
14401 0 : *result = r.out.result;
14402 :
14403 0 : return NT_STATUS_OK;
14404 : }
14405 :
14406 : struct dcerpc_clusapi_ReAddNotifyGroup_r_state {
14407 : TALLOC_CTX *out_mem_ctx;
14408 : };
14409 :
14410 : static void dcerpc_clusapi_ReAddNotifyGroup_r_done(struct tevent_req *subreq);
14411 :
14412 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyGroup_r_send(TALLOC_CTX *mem_ctx,
14413 : struct tevent_context *ev,
14414 : struct dcerpc_binding_handle *h,
14415 : struct clusapi_ReAddNotifyGroup *r)
14416 : {
14417 : struct tevent_req *req;
14418 : struct dcerpc_clusapi_ReAddNotifyGroup_r_state *state;
14419 : struct tevent_req *subreq;
14420 :
14421 0 : req = tevent_req_create(mem_ctx, &state,
14422 : struct dcerpc_clusapi_ReAddNotifyGroup_r_state);
14423 0 : if (req == NULL) {
14424 0 : return NULL;
14425 : }
14426 :
14427 0 : state->out_mem_ctx = talloc_new(state);
14428 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14429 0 : return tevent_req_post(req, ev);
14430 : }
14431 :
14432 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
14433 : NULL, &ndr_table_clusapi,
14434 0 : NDR_CLUSAPI_READDNOTIFYGROUP, state->out_mem_ctx, r);
14435 0 : if (tevent_req_nomem(subreq, req)) {
14436 0 : return tevent_req_post(req, ev);
14437 : }
14438 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyGroup_r_done, req);
14439 :
14440 0 : return req;
14441 : }
14442 :
14443 0 : static void dcerpc_clusapi_ReAddNotifyGroup_r_done(struct tevent_req *subreq)
14444 : {
14445 0 : struct tevent_req *req =
14446 0 : tevent_req_callback_data(subreq,
14447 : struct tevent_req);
14448 : NTSTATUS status;
14449 :
14450 0 : status = dcerpc_binding_handle_call_recv(subreq);
14451 0 : TALLOC_FREE(subreq);
14452 0 : if (tevent_req_nterror(req, status)) {
14453 0 : return;
14454 : }
14455 :
14456 0 : tevent_req_done(req);
14457 : }
14458 :
14459 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyGroup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
14460 : {
14461 0 : struct dcerpc_clusapi_ReAddNotifyGroup_r_state *state =
14462 0 : tevent_req_data(req,
14463 : struct dcerpc_clusapi_ReAddNotifyGroup_r_state);
14464 : NTSTATUS status;
14465 :
14466 0 : if (tevent_req_is_nterror(req, &status)) {
14467 0 : tevent_req_received(req);
14468 0 : return status;
14469 : }
14470 :
14471 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14472 :
14473 0 : tevent_req_received(req);
14474 0 : return NT_STATUS_OK;
14475 : }
14476 :
14477 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyGroup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ReAddNotifyGroup *r)
14478 : {
14479 : NTSTATUS status;
14480 :
14481 0 : status = dcerpc_binding_handle_call(h,
14482 : NULL, &ndr_table_clusapi,
14483 : NDR_CLUSAPI_READDNOTIFYGROUP, mem_ctx, r);
14484 :
14485 0 : return status;
14486 : }
14487 :
14488 : struct dcerpc_clusapi_ReAddNotifyGroup_state {
14489 : struct clusapi_ReAddNotifyGroup orig;
14490 : struct clusapi_ReAddNotifyGroup tmp;
14491 : TALLOC_CTX *out_mem_ctx;
14492 : };
14493 :
14494 : static void dcerpc_clusapi_ReAddNotifyGroup_done(struct tevent_req *subreq);
14495 :
14496 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyGroup_send(TALLOC_CTX *mem_ctx,
14497 : struct tevent_context *ev,
14498 : struct dcerpc_binding_handle *h,
14499 : struct policy_handle _hNotify /* [in] */,
14500 : struct policy_handle _hGroup /* [in] */,
14501 : uint32_t _dwFilter /* [in] */,
14502 : uint32_t _dwNotifyKey /* [in] */,
14503 : uint32_t _StateSequence /* [in] */,
14504 : WERROR *_rpc_status /* [out] [ref] */)
14505 : {
14506 : struct tevent_req *req;
14507 : struct dcerpc_clusapi_ReAddNotifyGroup_state *state;
14508 : struct tevent_req *subreq;
14509 :
14510 0 : req = tevent_req_create(mem_ctx, &state,
14511 : struct dcerpc_clusapi_ReAddNotifyGroup_state);
14512 0 : if (req == NULL) {
14513 0 : return NULL;
14514 : }
14515 0 : state->out_mem_ctx = NULL;
14516 :
14517 : /* In parameters */
14518 0 : state->orig.in.hNotify = _hNotify;
14519 0 : state->orig.in.hGroup = _hGroup;
14520 0 : state->orig.in.dwFilter = _dwFilter;
14521 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
14522 0 : state->orig.in.StateSequence = _StateSequence;
14523 :
14524 : /* Out parameters */
14525 0 : state->orig.out.rpc_status = _rpc_status;
14526 :
14527 : /* Result */
14528 0 : NDR_ZERO_STRUCT(state->orig.out.result);
14529 :
14530 0 : state->out_mem_ctx = talloc_named_const(state, 0,
14531 : "dcerpc_clusapi_ReAddNotifyGroup_out_memory");
14532 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14533 0 : return tevent_req_post(req, ev);
14534 : }
14535 :
14536 : /* make a temporary copy, that we pass to the dispatch function */
14537 0 : state->tmp = state->orig;
14538 :
14539 0 : subreq = dcerpc_clusapi_ReAddNotifyGroup_r_send(state, ev, h, &state->tmp);
14540 0 : if (tevent_req_nomem(subreq, req)) {
14541 0 : return tevent_req_post(req, ev);
14542 : }
14543 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyGroup_done, req);
14544 0 : return req;
14545 : }
14546 :
14547 0 : static void dcerpc_clusapi_ReAddNotifyGroup_done(struct tevent_req *subreq)
14548 : {
14549 0 : struct tevent_req *req = tevent_req_callback_data(
14550 : subreq, struct tevent_req);
14551 0 : struct dcerpc_clusapi_ReAddNotifyGroup_state *state = tevent_req_data(
14552 : req, struct dcerpc_clusapi_ReAddNotifyGroup_state);
14553 : NTSTATUS status;
14554 : TALLOC_CTX *mem_ctx;
14555 :
14556 0 : if (state->out_mem_ctx) {
14557 0 : mem_ctx = state->out_mem_ctx;
14558 : } else {
14559 0 : mem_ctx = state;
14560 : }
14561 :
14562 0 : status = dcerpc_clusapi_ReAddNotifyGroup_r_recv(subreq, mem_ctx);
14563 0 : TALLOC_FREE(subreq);
14564 0 : if (tevent_req_nterror(req, status)) {
14565 0 : return;
14566 : }
14567 :
14568 : /* Copy out parameters */
14569 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
14570 :
14571 : /* Copy result */
14572 0 : state->orig.out.result = state->tmp.out.result;
14573 :
14574 : /* Reset temporary structure */
14575 0 : NDR_ZERO_STRUCT(state->tmp);
14576 :
14577 0 : tevent_req_done(req);
14578 : }
14579 :
14580 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyGroup_recv(struct tevent_req *req,
14581 : TALLOC_CTX *mem_ctx,
14582 : WERROR *result)
14583 : {
14584 0 : struct dcerpc_clusapi_ReAddNotifyGroup_state *state = tevent_req_data(
14585 : req, struct dcerpc_clusapi_ReAddNotifyGroup_state);
14586 : NTSTATUS status;
14587 :
14588 0 : if (tevent_req_is_nterror(req, &status)) {
14589 0 : tevent_req_received(req);
14590 0 : return status;
14591 : }
14592 :
14593 : /* Steal possible out parameters to the callers context */
14594 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14595 :
14596 : /* Return result */
14597 0 : *result = state->orig.out.result;
14598 :
14599 0 : tevent_req_received(req);
14600 0 : return NT_STATUS_OK;
14601 : }
14602 :
14603 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyGroup(struct dcerpc_binding_handle *h,
14604 : TALLOC_CTX *mem_ctx,
14605 : struct policy_handle _hNotify /* [in] */,
14606 : struct policy_handle _hGroup /* [in] */,
14607 : uint32_t _dwFilter /* [in] */,
14608 : uint32_t _dwNotifyKey /* [in] */,
14609 : uint32_t _StateSequence /* [in] */,
14610 : WERROR *_rpc_status /* [out] [ref] */,
14611 : WERROR *result)
14612 : {
14613 : struct clusapi_ReAddNotifyGroup r;
14614 : NTSTATUS status;
14615 :
14616 : /* In parameters */
14617 0 : r.in.hNotify = _hNotify;
14618 0 : r.in.hGroup = _hGroup;
14619 0 : r.in.dwFilter = _dwFilter;
14620 0 : r.in.dwNotifyKey = _dwNotifyKey;
14621 0 : r.in.StateSequence = _StateSequence;
14622 :
14623 : /* Out parameters */
14624 0 : r.out.rpc_status = _rpc_status;
14625 :
14626 : /* Result */
14627 0 : NDR_ZERO_STRUCT(r.out.result);
14628 :
14629 0 : status = dcerpc_clusapi_ReAddNotifyGroup_r(h, mem_ctx, &r);
14630 0 : if (!NT_STATUS_IS_OK(status)) {
14631 0 : return status;
14632 : }
14633 :
14634 : /* Return variables */
14635 0 : *_rpc_status = *r.out.rpc_status;
14636 :
14637 : /* Return result */
14638 0 : *result = r.out.result;
14639 :
14640 0 : return NT_STATUS_OK;
14641 : }
14642 :
14643 : struct dcerpc_clusapi_ReAddNotifyResource_r_state {
14644 : TALLOC_CTX *out_mem_ctx;
14645 : };
14646 :
14647 : static void dcerpc_clusapi_ReAddNotifyResource_r_done(struct tevent_req *subreq);
14648 :
14649 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyResource_r_send(TALLOC_CTX *mem_ctx,
14650 : struct tevent_context *ev,
14651 : struct dcerpc_binding_handle *h,
14652 : struct clusapi_ReAddNotifyResource *r)
14653 : {
14654 : struct tevent_req *req;
14655 : struct dcerpc_clusapi_ReAddNotifyResource_r_state *state;
14656 : struct tevent_req *subreq;
14657 :
14658 0 : req = tevent_req_create(mem_ctx, &state,
14659 : struct dcerpc_clusapi_ReAddNotifyResource_r_state);
14660 0 : if (req == NULL) {
14661 0 : return NULL;
14662 : }
14663 :
14664 0 : state->out_mem_ctx = talloc_new(state);
14665 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14666 0 : return tevent_req_post(req, ev);
14667 : }
14668 :
14669 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
14670 : NULL, &ndr_table_clusapi,
14671 0 : NDR_CLUSAPI_READDNOTIFYRESOURCE, state->out_mem_ctx, r);
14672 0 : if (tevent_req_nomem(subreq, req)) {
14673 0 : return tevent_req_post(req, ev);
14674 : }
14675 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyResource_r_done, req);
14676 :
14677 0 : return req;
14678 : }
14679 :
14680 0 : static void dcerpc_clusapi_ReAddNotifyResource_r_done(struct tevent_req *subreq)
14681 : {
14682 0 : struct tevent_req *req =
14683 0 : tevent_req_callback_data(subreq,
14684 : struct tevent_req);
14685 : NTSTATUS status;
14686 :
14687 0 : status = dcerpc_binding_handle_call_recv(subreq);
14688 0 : TALLOC_FREE(subreq);
14689 0 : if (tevent_req_nterror(req, status)) {
14690 0 : return;
14691 : }
14692 :
14693 0 : tevent_req_done(req);
14694 : }
14695 :
14696 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
14697 : {
14698 0 : struct dcerpc_clusapi_ReAddNotifyResource_r_state *state =
14699 0 : tevent_req_data(req,
14700 : struct dcerpc_clusapi_ReAddNotifyResource_r_state);
14701 : NTSTATUS status;
14702 :
14703 0 : if (tevent_req_is_nterror(req, &status)) {
14704 0 : tevent_req_received(req);
14705 0 : return status;
14706 : }
14707 :
14708 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14709 :
14710 0 : tevent_req_received(req);
14711 0 : return NT_STATUS_OK;
14712 : }
14713 :
14714 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ReAddNotifyResource *r)
14715 : {
14716 : NTSTATUS status;
14717 :
14718 0 : status = dcerpc_binding_handle_call(h,
14719 : NULL, &ndr_table_clusapi,
14720 : NDR_CLUSAPI_READDNOTIFYRESOURCE, mem_ctx, r);
14721 :
14722 0 : return status;
14723 : }
14724 :
14725 : struct dcerpc_clusapi_ReAddNotifyResource_state {
14726 : struct clusapi_ReAddNotifyResource orig;
14727 : struct clusapi_ReAddNotifyResource tmp;
14728 : TALLOC_CTX *out_mem_ctx;
14729 : };
14730 :
14731 : static void dcerpc_clusapi_ReAddNotifyResource_done(struct tevent_req *subreq);
14732 :
14733 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyResource_send(TALLOC_CTX *mem_ctx,
14734 : struct tevent_context *ev,
14735 : struct dcerpc_binding_handle *h,
14736 : struct policy_handle _hNotify /* [in] */,
14737 : struct policy_handle _hResource /* [in] */,
14738 : uint32_t _dwFilter /* [in] */,
14739 : uint32_t _dwNotifyKey /* [in] */,
14740 : uint32_t _StateSequence /* [in] */,
14741 : WERROR *_rpc_status /* [out] [ref] */)
14742 : {
14743 : struct tevent_req *req;
14744 : struct dcerpc_clusapi_ReAddNotifyResource_state *state;
14745 : struct tevent_req *subreq;
14746 :
14747 0 : req = tevent_req_create(mem_ctx, &state,
14748 : struct dcerpc_clusapi_ReAddNotifyResource_state);
14749 0 : if (req == NULL) {
14750 0 : return NULL;
14751 : }
14752 0 : state->out_mem_ctx = NULL;
14753 :
14754 : /* In parameters */
14755 0 : state->orig.in.hNotify = _hNotify;
14756 0 : state->orig.in.hResource = _hResource;
14757 0 : state->orig.in.dwFilter = _dwFilter;
14758 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
14759 0 : state->orig.in.StateSequence = _StateSequence;
14760 :
14761 : /* Out parameters */
14762 0 : state->orig.out.rpc_status = _rpc_status;
14763 :
14764 : /* Result */
14765 0 : NDR_ZERO_STRUCT(state->orig.out.result);
14766 :
14767 0 : state->out_mem_ctx = talloc_named_const(state, 0,
14768 : "dcerpc_clusapi_ReAddNotifyResource_out_memory");
14769 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14770 0 : return tevent_req_post(req, ev);
14771 : }
14772 :
14773 : /* make a temporary copy, that we pass to the dispatch function */
14774 0 : state->tmp = state->orig;
14775 :
14776 0 : subreq = dcerpc_clusapi_ReAddNotifyResource_r_send(state, ev, h, &state->tmp);
14777 0 : if (tevent_req_nomem(subreq, req)) {
14778 0 : return tevent_req_post(req, ev);
14779 : }
14780 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyResource_done, req);
14781 0 : return req;
14782 : }
14783 :
14784 0 : static void dcerpc_clusapi_ReAddNotifyResource_done(struct tevent_req *subreq)
14785 : {
14786 0 : struct tevent_req *req = tevent_req_callback_data(
14787 : subreq, struct tevent_req);
14788 0 : struct dcerpc_clusapi_ReAddNotifyResource_state *state = tevent_req_data(
14789 : req, struct dcerpc_clusapi_ReAddNotifyResource_state);
14790 : NTSTATUS status;
14791 : TALLOC_CTX *mem_ctx;
14792 :
14793 0 : if (state->out_mem_ctx) {
14794 0 : mem_ctx = state->out_mem_ctx;
14795 : } else {
14796 0 : mem_ctx = state;
14797 : }
14798 :
14799 0 : status = dcerpc_clusapi_ReAddNotifyResource_r_recv(subreq, mem_ctx);
14800 0 : TALLOC_FREE(subreq);
14801 0 : if (tevent_req_nterror(req, status)) {
14802 0 : return;
14803 : }
14804 :
14805 : /* Copy out parameters */
14806 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
14807 :
14808 : /* Copy result */
14809 0 : state->orig.out.result = state->tmp.out.result;
14810 :
14811 : /* Reset temporary structure */
14812 0 : NDR_ZERO_STRUCT(state->tmp);
14813 :
14814 0 : tevent_req_done(req);
14815 : }
14816 :
14817 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyResource_recv(struct tevent_req *req,
14818 : TALLOC_CTX *mem_ctx,
14819 : WERROR *result)
14820 : {
14821 0 : struct dcerpc_clusapi_ReAddNotifyResource_state *state = tevent_req_data(
14822 : req, struct dcerpc_clusapi_ReAddNotifyResource_state);
14823 : NTSTATUS status;
14824 :
14825 0 : if (tevent_req_is_nterror(req, &status)) {
14826 0 : tevent_req_received(req);
14827 0 : return status;
14828 : }
14829 :
14830 : /* Steal possible out parameters to the callers context */
14831 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14832 :
14833 : /* Return result */
14834 0 : *result = state->orig.out.result;
14835 :
14836 0 : tevent_req_received(req);
14837 0 : return NT_STATUS_OK;
14838 : }
14839 :
14840 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyResource(struct dcerpc_binding_handle *h,
14841 : TALLOC_CTX *mem_ctx,
14842 : struct policy_handle _hNotify /* [in] */,
14843 : struct policy_handle _hResource /* [in] */,
14844 : uint32_t _dwFilter /* [in] */,
14845 : uint32_t _dwNotifyKey /* [in] */,
14846 : uint32_t _StateSequence /* [in] */,
14847 : WERROR *_rpc_status /* [out] [ref] */,
14848 : WERROR *result)
14849 : {
14850 : struct clusapi_ReAddNotifyResource r;
14851 : NTSTATUS status;
14852 :
14853 : /* In parameters */
14854 0 : r.in.hNotify = _hNotify;
14855 0 : r.in.hResource = _hResource;
14856 0 : r.in.dwFilter = _dwFilter;
14857 0 : r.in.dwNotifyKey = _dwNotifyKey;
14858 0 : r.in.StateSequence = _StateSequence;
14859 :
14860 : /* Out parameters */
14861 0 : r.out.rpc_status = _rpc_status;
14862 :
14863 : /* Result */
14864 0 : NDR_ZERO_STRUCT(r.out.result);
14865 :
14866 0 : status = dcerpc_clusapi_ReAddNotifyResource_r(h, mem_ctx, &r);
14867 0 : if (!NT_STATUS_IS_OK(status)) {
14868 0 : return status;
14869 : }
14870 :
14871 : /* Return variables */
14872 0 : *_rpc_status = *r.out.rpc_status;
14873 :
14874 : /* Return result */
14875 0 : *result = r.out.result;
14876 :
14877 0 : return NT_STATUS_OK;
14878 : }
14879 :
14880 : struct dcerpc_clusapi_GetNotify_r_state {
14881 : TALLOC_CTX *out_mem_ctx;
14882 : };
14883 :
14884 : static void dcerpc_clusapi_GetNotify_r_done(struct tevent_req *subreq);
14885 :
14886 0 : struct tevent_req *dcerpc_clusapi_GetNotify_r_send(TALLOC_CTX *mem_ctx,
14887 : struct tevent_context *ev,
14888 : struct dcerpc_binding_handle *h,
14889 : struct clusapi_GetNotify *r)
14890 : {
14891 : struct tevent_req *req;
14892 : struct dcerpc_clusapi_GetNotify_r_state *state;
14893 : struct tevent_req *subreq;
14894 :
14895 0 : req = tevent_req_create(mem_ctx, &state,
14896 : struct dcerpc_clusapi_GetNotify_r_state);
14897 0 : if (req == NULL) {
14898 0 : return NULL;
14899 : }
14900 :
14901 0 : state->out_mem_ctx = talloc_new(state);
14902 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
14903 0 : return tevent_req_post(req, ev);
14904 : }
14905 :
14906 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
14907 : NULL, &ndr_table_clusapi,
14908 0 : NDR_CLUSAPI_GETNOTIFY, state->out_mem_ctx, r);
14909 0 : if (tevent_req_nomem(subreq, req)) {
14910 0 : return tevent_req_post(req, ev);
14911 : }
14912 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotify_r_done, req);
14913 :
14914 0 : return req;
14915 : }
14916 :
14917 0 : static void dcerpc_clusapi_GetNotify_r_done(struct tevent_req *subreq)
14918 : {
14919 0 : struct tevent_req *req =
14920 0 : tevent_req_callback_data(subreq,
14921 : struct tevent_req);
14922 : NTSTATUS status;
14923 :
14924 0 : status = dcerpc_binding_handle_call_recv(subreq);
14925 0 : TALLOC_FREE(subreq);
14926 0 : if (tevent_req_nterror(req, status)) {
14927 0 : return;
14928 : }
14929 :
14930 0 : tevent_req_done(req);
14931 : }
14932 :
14933 0 : NTSTATUS dcerpc_clusapi_GetNotify_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
14934 : {
14935 0 : struct dcerpc_clusapi_GetNotify_r_state *state =
14936 0 : tevent_req_data(req,
14937 : struct dcerpc_clusapi_GetNotify_r_state);
14938 : NTSTATUS status;
14939 :
14940 0 : if (tevent_req_is_nterror(req, &status)) {
14941 0 : tevent_req_received(req);
14942 0 : return status;
14943 : }
14944 :
14945 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
14946 :
14947 0 : tevent_req_received(req);
14948 0 : return NT_STATUS_OK;
14949 : }
14950 :
14951 0 : NTSTATUS dcerpc_clusapi_GetNotify_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNotify *r)
14952 : {
14953 : NTSTATUS status;
14954 :
14955 0 : status = dcerpc_binding_handle_call(h,
14956 : NULL, &ndr_table_clusapi,
14957 : NDR_CLUSAPI_GETNOTIFY, mem_ctx, r);
14958 :
14959 0 : return status;
14960 : }
14961 :
14962 : struct dcerpc_clusapi_GetNotify_state {
14963 : struct clusapi_GetNotify orig;
14964 : struct clusapi_GetNotify tmp;
14965 : TALLOC_CTX *out_mem_ctx;
14966 : };
14967 :
14968 : static void dcerpc_clusapi_GetNotify_done(struct tevent_req *subreq);
14969 :
14970 0 : struct tevent_req *dcerpc_clusapi_GetNotify_send(TALLOC_CTX *mem_ctx,
14971 : struct tevent_context *ev,
14972 : struct dcerpc_binding_handle *h,
14973 : struct policy_handle _hNotify /* [in] */,
14974 : uint32_t *_dwNotifyKey /* [out] [ref] */,
14975 : uint32_t *_dwFilter /* [out] [ref] */,
14976 : uint32_t *_dwStateSequence /* [out] [ref] */,
14977 : const char **_Name /* [out] [charset(UTF16),ref] */,
14978 : WERROR *_rpc_status /* [out] [ref] */)
14979 : {
14980 : struct tevent_req *req;
14981 : struct dcerpc_clusapi_GetNotify_state *state;
14982 : struct tevent_req *subreq;
14983 :
14984 0 : req = tevent_req_create(mem_ctx, &state,
14985 : struct dcerpc_clusapi_GetNotify_state);
14986 0 : if (req == NULL) {
14987 0 : return NULL;
14988 : }
14989 0 : state->out_mem_ctx = NULL;
14990 :
14991 : /* In parameters */
14992 0 : state->orig.in.hNotify = _hNotify;
14993 :
14994 : /* Out parameters */
14995 0 : state->orig.out.dwNotifyKey = _dwNotifyKey;
14996 0 : state->orig.out.dwFilter = _dwFilter;
14997 0 : state->orig.out.dwStateSequence = _dwStateSequence;
14998 0 : state->orig.out.Name = _Name;
14999 0 : state->orig.out.rpc_status = _rpc_status;
15000 :
15001 : /* Result */
15002 0 : NDR_ZERO_STRUCT(state->orig.out.result);
15003 :
15004 0 : state->out_mem_ctx = talloc_named_const(state, 0,
15005 : "dcerpc_clusapi_GetNotify_out_memory");
15006 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15007 0 : return tevent_req_post(req, ev);
15008 : }
15009 :
15010 : /* make a temporary copy, that we pass to the dispatch function */
15011 0 : state->tmp = state->orig;
15012 :
15013 0 : subreq = dcerpc_clusapi_GetNotify_r_send(state, ev, h, &state->tmp);
15014 0 : if (tevent_req_nomem(subreq, req)) {
15015 0 : return tevent_req_post(req, ev);
15016 : }
15017 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotify_done, req);
15018 0 : return req;
15019 : }
15020 :
15021 0 : static void dcerpc_clusapi_GetNotify_done(struct tevent_req *subreq)
15022 : {
15023 0 : struct tevent_req *req = tevent_req_callback_data(
15024 : subreq, struct tevent_req);
15025 0 : struct dcerpc_clusapi_GetNotify_state *state = tevent_req_data(
15026 : req, struct dcerpc_clusapi_GetNotify_state);
15027 : NTSTATUS status;
15028 : TALLOC_CTX *mem_ctx;
15029 :
15030 0 : if (state->out_mem_ctx) {
15031 0 : mem_ctx = state->out_mem_ctx;
15032 : } else {
15033 0 : mem_ctx = state;
15034 : }
15035 :
15036 0 : status = dcerpc_clusapi_GetNotify_r_recv(subreq, mem_ctx);
15037 0 : TALLOC_FREE(subreq);
15038 0 : if (tevent_req_nterror(req, status)) {
15039 0 : return;
15040 : }
15041 :
15042 : /* Copy out parameters */
15043 0 : *state->orig.out.dwNotifyKey = *state->tmp.out.dwNotifyKey;
15044 0 : *state->orig.out.dwFilter = *state->tmp.out.dwFilter;
15045 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
15046 0 : *state->orig.out.Name = *state->tmp.out.Name;
15047 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
15048 :
15049 : /* Copy result */
15050 0 : state->orig.out.result = state->tmp.out.result;
15051 :
15052 : /* Reset temporary structure */
15053 0 : NDR_ZERO_STRUCT(state->tmp);
15054 :
15055 0 : tevent_req_done(req);
15056 : }
15057 :
15058 0 : NTSTATUS dcerpc_clusapi_GetNotify_recv(struct tevent_req *req,
15059 : TALLOC_CTX *mem_ctx,
15060 : WERROR *result)
15061 : {
15062 0 : struct dcerpc_clusapi_GetNotify_state *state = tevent_req_data(
15063 : req, struct dcerpc_clusapi_GetNotify_state);
15064 : NTSTATUS status;
15065 :
15066 0 : if (tevent_req_is_nterror(req, &status)) {
15067 0 : tevent_req_received(req);
15068 0 : return status;
15069 : }
15070 :
15071 : /* Steal possible out parameters to the callers context */
15072 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15073 :
15074 : /* Return result */
15075 0 : *result = state->orig.out.result;
15076 :
15077 0 : tevent_req_received(req);
15078 0 : return NT_STATUS_OK;
15079 : }
15080 :
15081 0 : NTSTATUS dcerpc_clusapi_GetNotify(struct dcerpc_binding_handle *h,
15082 : TALLOC_CTX *mem_ctx,
15083 : struct policy_handle _hNotify /* [in] */,
15084 : uint32_t *_dwNotifyKey /* [out] [ref] */,
15085 : uint32_t *_dwFilter /* [out] [ref] */,
15086 : uint32_t *_dwStateSequence /* [out] [ref] */,
15087 : const char **_Name /* [out] [charset(UTF16),ref] */,
15088 : WERROR *_rpc_status /* [out] [ref] */,
15089 : WERROR *result)
15090 : {
15091 : struct clusapi_GetNotify r;
15092 : NTSTATUS status;
15093 :
15094 : /* In parameters */
15095 0 : r.in.hNotify = _hNotify;
15096 :
15097 : /* Out parameters */
15098 0 : r.out.dwNotifyKey = _dwNotifyKey;
15099 0 : r.out.dwFilter = _dwFilter;
15100 0 : r.out.dwStateSequence = _dwStateSequence;
15101 0 : r.out.Name = _Name;
15102 0 : r.out.rpc_status = _rpc_status;
15103 :
15104 : /* Result */
15105 0 : NDR_ZERO_STRUCT(r.out.result);
15106 :
15107 0 : status = dcerpc_clusapi_GetNotify_r(h, mem_ctx, &r);
15108 0 : if (!NT_STATUS_IS_OK(status)) {
15109 0 : return status;
15110 : }
15111 :
15112 : /* Return variables */
15113 0 : *_dwNotifyKey = *r.out.dwNotifyKey;
15114 0 : *_dwFilter = *r.out.dwFilter;
15115 0 : *_dwStateSequence = *r.out.dwStateSequence;
15116 0 : *_Name = *r.out.Name;
15117 0 : *_rpc_status = *r.out.rpc_status;
15118 :
15119 : /* Return result */
15120 0 : *result = r.out.result;
15121 :
15122 0 : return NT_STATUS_OK;
15123 : }
15124 :
15125 : struct dcerpc_clusapi_OpenNode_r_state {
15126 : TALLOC_CTX *out_mem_ctx;
15127 : };
15128 :
15129 : static void dcerpc_clusapi_OpenNode_r_done(struct tevent_req *subreq);
15130 :
15131 0 : struct tevent_req *dcerpc_clusapi_OpenNode_r_send(TALLOC_CTX *mem_ctx,
15132 : struct tevent_context *ev,
15133 : struct dcerpc_binding_handle *h,
15134 : struct clusapi_OpenNode *r)
15135 : {
15136 : struct tevent_req *req;
15137 : struct dcerpc_clusapi_OpenNode_r_state *state;
15138 : struct tevent_req *subreq;
15139 :
15140 0 : req = tevent_req_create(mem_ctx, &state,
15141 : struct dcerpc_clusapi_OpenNode_r_state);
15142 0 : if (req == NULL) {
15143 0 : return NULL;
15144 : }
15145 :
15146 0 : state->out_mem_ctx = talloc_new(state);
15147 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15148 0 : return tevent_req_post(req, ev);
15149 : }
15150 :
15151 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
15152 : NULL, &ndr_table_clusapi,
15153 0 : NDR_CLUSAPI_OPENNODE, state->out_mem_ctx, r);
15154 0 : if (tevent_req_nomem(subreq, req)) {
15155 0 : return tevent_req_post(req, ev);
15156 : }
15157 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNode_r_done, req);
15158 :
15159 0 : return req;
15160 : }
15161 :
15162 0 : static void dcerpc_clusapi_OpenNode_r_done(struct tevent_req *subreq)
15163 : {
15164 0 : struct tevent_req *req =
15165 0 : tevent_req_callback_data(subreq,
15166 : struct tevent_req);
15167 : NTSTATUS status;
15168 :
15169 0 : status = dcerpc_binding_handle_call_recv(subreq);
15170 0 : TALLOC_FREE(subreq);
15171 0 : if (tevent_req_nterror(req, status)) {
15172 0 : return;
15173 : }
15174 :
15175 0 : tevent_req_done(req);
15176 : }
15177 :
15178 0 : NTSTATUS dcerpc_clusapi_OpenNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
15179 : {
15180 0 : struct dcerpc_clusapi_OpenNode_r_state *state =
15181 0 : tevent_req_data(req,
15182 : struct dcerpc_clusapi_OpenNode_r_state);
15183 : NTSTATUS status;
15184 :
15185 0 : if (tevent_req_is_nterror(req, &status)) {
15186 0 : tevent_req_received(req);
15187 0 : return status;
15188 : }
15189 :
15190 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15191 :
15192 0 : tevent_req_received(req);
15193 0 : return NT_STATUS_OK;
15194 : }
15195 :
15196 0 : NTSTATUS dcerpc_clusapi_OpenNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNode *r)
15197 : {
15198 : NTSTATUS status;
15199 :
15200 0 : status = dcerpc_binding_handle_call(h,
15201 : NULL, &ndr_table_clusapi,
15202 : NDR_CLUSAPI_OPENNODE, mem_ctx, r);
15203 :
15204 0 : return status;
15205 : }
15206 :
15207 : struct dcerpc_clusapi_OpenNode_state {
15208 : struct clusapi_OpenNode orig;
15209 : struct clusapi_OpenNode tmp;
15210 : TALLOC_CTX *out_mem_ctx;
15211 : };
15212 :
15213 : static void dcerpc_clusapi_OpenNode_done(struct tevent_req *subreq);
15214 :
15215 0 : struct tevent_req *dcerpc_clusapi_OpenNode_send(TALLOC_CTX *mem_ctx,
15216 : struct tevent_context *ev,
15217 : struct dcerpc_binding_handle *h,
15218 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
15219 : WERROR *_Status /* [out] [ref] */,
15220 : WERROR *_rpc_status /* [out] [ref] */,
15221 : struct policy_handle *_hNode /* [out] [ref] */)
15222 : {
15223 : struct tevent_req *req;
15224 : struct dcerpc_clusapi_OpenNode_state *state;
15225 : struct tevent_req *subreq;
15226 :
15227 0 : req = tevent_req_create(mem_ctx, &state,
15228 : struct dcerpc_clusapi_OpenNode_state);
15229 0 : if (req == NULL) {
15230 0 : return NULL;
15231 : }
15232 0 : state->out_mem_ctx = NULL;
15233 :
15234 : /* In parameters */
15235 0 : state->orig.in.lpszNodeName = _lpszNodeName;
15236 :
15237 : /* Out parameters */
15238 0 : state->orig.out.Status = _Status;
15239 0 : state->orig.out.rpc_status = _rpc_status;
15240 0 : state->orig.out.hNode = _hNode;
15241 :
15242 0 : state->out_mem_ctx = talloc_named_const(state, 0,
15243 : "dcerpc_clusapi_OpenNode_out_memory");
15244 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15245 0 : return tevent_req_post(req, ev);
15246 : }
15247 :
15248 : /* make a temporary copy, that we pass to the dispatch function */
15249 0 : state->tmp = state->orig;
15250 :
15251 0 : subreq = dcerpc_clusapi_OpenNode_r_send(state, ev, h, &state->tmp);
15252 0 : if (tevent_req_nomem(subreq, req)) {
15253 0 : return tevent_req_post(req, ev);
15254 : }
15255 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNode_done, req);
15256 0 : return req;
15257 : }
15258 :
15259 0 : static void dcerpc_clusapi_OpenNode_done(struct tevent_req *subreq)
15260 : {
15261 0 : struct tevent_req *req = tevent_req_callback_data(
15262 : subreq, struct tevent_req);
15263 0 : struct dcerpc_clusapi_OpenNode_state *state = tevent_req_data(
15264 : req, struct dcerpc_clusapi_OpenNode_state);
15265 : NTSTATUS status;
15266 : TALLOC_CTX *mem_ctx;
15267 :
15268 0 : if (state->out_mem_ctx) {
15269 0 : mem_ctx = state->out_mem_ctx;
15270 : } else {
15271 0 : mem_ctx = state;
15272 : }
15273 :
15274 0 : status = dcerpc_clusapi_OpenNode_r_recv(subreq, mem_ctx);
15275 0 : TALLOC_FREE(subreq);
15276 0 : if (tevent_req_nterror(req, status)) {
15277 0 : return;
15278 : }
15279 :
15280 : /* Copy out parameters */
15281 0 : *state->orig.out.Status = *state->tmp.out.Status;
15282 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
15283 0 : *state->orig.out.hNode = *state->tmp.out.hNode;
15284 :
15285 : /* Reset temporary structure */
15286 0 : NDR_ZERO_STRUCT(state->tmp);
15287 :
15288 0 : tevent_req_done(req);
15289 : }
15290 :
15291 0 : NTSTATUS dcerpc_clusapi_OpenNode_recv(struct tevent_req *req,
15292 : TALLOC_CTX *mem_ctx)
15293 : {
15294 0 : struct dcerpc_clusapi_OpenNode_state *state = tevent_req_data(
15295 : req, struct dcerpc_clusapi_OpenNode_state);
15296 : NTSTATUS status;
15297 :
15298 0 : if (tevent_req_is_nterror(req, &status)) {
15299 0 : tevent_req_received(req);
15300 0 : return status;
15301 : }
15302 :
15303 : /* Steal possible out parameters to the callers context */
15304 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15305 :
15306 0 : tevent_req_received(req);
15307 0 : return NT_STATUS_OK;
15308 : }
15309 :
15310 0 : NTSTATUS dcerpc_clusapi_OpenNode(struct dcerpc_binding_handle *h,
15311 : TALLOC_CTX *mem_ctx,
15312 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
15313 : WERROR *_Status /* [out] [ref] */,
15314 : WERROR *_rpc_status /* [out] [ref] */,
15315 : struct policy_handle *_hNode /* [out] [ref] */)
15316 : {
15317 : struct clusapi_OpenNode r;
15318 : NTSTATUS status;
15319 :
15320 : /* In parameters */
15321 0 : r.in.lpszNodeName = _lpszNodeName;
15322 :
15323 : /* Out parameters */
15324 0 : r.out.Status = _Status;
15325 0 : r.out.rpc_status = _rpc_status;
15326 0 : r.out.hNode = _hNode;
15327 :
15328 0 : status = dcerpc_clusapi_OpenNode_r(h, mem_ctx, &r);
15329 0 : if (!NT_STATUS_IS_OK(status)) {
15330 0 : return status;
15331 : }
15332 :
15333 : /* Return variables */
15334 0 : *_Status = *r.out.Status;
15335 0 : *_rpc_status = *r.out.rpc_status;
15336 0 : *_hNode = *r.out.hNode;
15337 :
15338 : /* Return result */
15339 :
15340 0 : return NT_STATUS_OK;
15341 : }
15342 :
15343 : struct dcerpc_clusapi_CloseNode_r_state {
15344 : TALLOC_CTX *out_mem_ctx;
15345 : };
15346 :
15347 : static void dcerpc_clusapi_CloseNode_r_done(struct tevent_req *subreq);
15348 :
15349 0 : struct tevent_req *dcerpc_clusapi_CloseNode_r_send(TALLOC_CTX *mem_ctx,
15350 : struct tevent_context *ev,
15351 : struct dcerpc_binding_handle *h,
15352 : struct clusapi_CloseNode *r)
15353 : {
15354 : struct tevent_req *req;
15355 : struct dcerpc_clusapi_CloseNode_r_state *state;
15356 : struct tevent_req *subreq;
15357 :
15358 0 : req = tevent_req_create(mem_ctx, &state,
15359 : struct dcerpc_clusapi_CloseNode_r_state);
15360 0 : if (req == NULL) {
15361 0 : return NULL;
15362 : }
15363 :
15364 0 : state->out_mem_ctx = talloc_new(state);
15365 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15366 0 : return tevent_req_post(req, ev);
15367 : }
15368 :
15369 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
15370 : NULL, &ndr_table_clusapi,
15371 0 : NDR_CLUSAPI_CLOSENODE, state->out_mem_ctx, r);
15372 0 : if (tevent_req_nomem(subreq, req)) {
15373 0 : return tevent_req_post(req, ev);
15374 : }
15375 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNode_r_done, req);
15376 :
15377 0 : return req;
15378 : }
15379 :
15380 0 : static void dcerpc_clusapi_CloseNode_r_done(struct tevent_req *subreq)
15381 : {
15382 0 : struct tevent_req *req =
15383 0 : tevent_req_callback_data(subreq,
15384 : struct tevent_req);
15385 : NTSTATUS status;
15386 :
15387 0 : status = dcerpc_binding_handle_call_recv(subreq);
15388 0 : TALLOC_FREE(subreq);
15389 0 : if (tevent_req_nterror(req, status)) {
15390 0 : return;
15391 : }
15392 :
15393 0 : tevent_req_done(req);
15394 : }
15395 :
15396 0 : NTSTATUS dcerpc_clusapi_CloseNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
15397 : {
15398 0 : struct dcerpc_clusapi_CloseNode_r_state *state =
15399 0 : tevent_req_data(req,
15400 : struct dcerpc_clusapi_CloseNode_r_state);
15401 : NTSTATUS status;
15402 :
15403 0 : if (tevent_req_is_nterror(req, &status)) {
15404 0 : tevent_req_received(req);
15405 0 : return status;
15406 : }
15407 :
15408 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15409 :
15410 0 : tevent_req_received(req);
15411 0 : return NT_STATUS_OK;
15412 : }
15413 :
15414 0 : NTSTATUS dcerpc_clusapi_CloseNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseNode *r)
15415 : {
15416 : NTSTATUS status;
15417 :
15418 0 : status = dcerpc_binding_handle_call(h,
15419 : NULL, &ndr_table_clusapi,
15420 : NDR_CLUSAPI_CLOSENODE, mem_ctx, r);
15421 :
15422 0 : return status;
15423 : }
15424 :
15425 : struct dcerpc_clusapi_CloseNode_state {
15426 : struct clusapi_CloseNode orig;
15427 : struct clusapi_CloseNode tmp;
15428 : TALLOC_CTX *out_mem_ctx;
15429 : };
15430 :
15431 : static void dcerpc_clusapi_CloseNode_done(struct tevent_req *subreq);
15432 :
15433 0 : struct tevent_req *dcerpc_clusapi_CloseNode_send(TALLOC_CTX *mem_ctx,
15434 : struct tevent_context *ev,
15435 : struct dcerpc_binding_handle *h,
15436 : struct policy_handle *_Node /* [in,out] [ref] */)
15437 : {
15438 : struct tevent_req *req;
15439 : struct dcerpc_clusapi_CloseNode_state *state;
15440 : struct tevent_req *subreq;
15441 :
15442 0 : req = tevent_req_create(mem_ctx, &state,
15443 : struct dcerpc_clusapi_CloseNode_state);
15444 0 : if (req == NULL) {
15445 0 : return NULL;
15446 : }
15447 0 : state->out_mem_ctx = NULL;
15448 :
15449 : /* In parameters */
15450 0 : state->orig.in.Node = _Node;
15451 :
15452 : /* Out parameters */
15453 0 : state->orig.out.Node = _Node;
15454 :
15455 : /* Result */
15456 0 : NDR_ZERO_STRUCT(state->orig.out.result);
15457 :
15458 0 : state->out_mem_ctx = talloc_named_const(state, 0,
15459 : "dcerpc_clusapi_CloseNode_out_memory");
15460 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15461 0 : return tevent_req_post(req, ev);
15462 : }
15463 :
15464 : /* make a temporary copy, that we pass to the dispatch function */
15465 0 : state->tmp = state->orig;
15466 :
15467 0 : subreq = dcerpc_clusapi_CloseNode_r_send(state, ev, h, &state->tmp);
15468 0 : if (tevent_req_nomem(subreq, req)) {
15469 0 : return tevent_req_post(req, ev);
15470 : }
15471 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNode_done, req);
15472 0 : return req;
15473 : }
15474 :
15475 0 : static void dcerpc_clusapi_CloseNode_done(struct tevent_req *subreq)
15476 : {
15477 0 : struct tevent_req *req = tevent_req_callback_data(
15478 : subreq, struct tevent_req);
15479 0 : struct dcerpc_clusapi_CloseNode_state *state = tevent_req_data(
15480 : req, struct dcerpc_clusapi_CloseNode_state);
15481 : NTSTATUS status;
15482 : TALLOC_CTX *mem_ctx;
15483 :
15484 0 : if (state->out_mem_ctx) {
15485 0 : mem_ctx = state->out_mem_ctx;
15486 : } else {
15487 0 : mem_ctx = state;
15488 : }
15489 :
15490 0 : status = dcerpc_clusapi_CloseNode_r_recv(subreq, mem_ctx);
15491 0 : TALLOC_FREE(subreq);
15492 0 : if (tevent_req_nterror(req, status)) {
15493 0 : return;
15494 : }
15495 :
15496 : /* Copy out parameters */
15497 0 : *state->orig.out.Node = *state->tmp.out.Node;
15498 :
15499 : /* Copy result */
15500 0 : state->orig.out.result = state->tmp.out.result;
15501 :
15502 : /* Reset temporary structure */
15503 0 : NDR_ZERO_STRUCT(state->tmp);
15504 :
15505 0 : tevent_req_done(req);
15506 : }
15507 :
15508 0 : NTSTATUS dcerpc_clusapi_CloseNode_recv(struct tevent_req *req,
15509 : TALLOC_CTX *mem_ctx,
15510 : WERROR *result)
15511 : {
15512 0 : struct dcerpc_clusapi_CloseNode_state *state = tevent_req_data(
15513 : req, struct dcerpc_clusapi_CloseNode_state);
15514 : NTSTATUS status;
15515 :
15516 0 : if (tevent_req_is_nterror(req, &status)) {
15517 0 : tevent_req_received(req);
15518 0 : return status;
15519 : }
15520 :
15521 : /* Steal possible out parameters to the callers context */
15522 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15523 :
15524 : /* Return result */
15525 0 : *result = state->orig.out.result;
15526 :
15527 0 : tevent_req_received(req);
15528 0 : return NT_STATUS_OK;
15529 : }
15530 :
15531 0 : NTSTATUS dcerpc_clusapi_CloseNode(struct dcerpc_binding_handle *h,
15532 : TALLOC_CTX *mem_ctx,
15533 : struct policy_handle *_Node /* [in,out] [ref] */,
15534 : WERROR *result)
15535 : {
15536 : struct clusapi_CloseNode r;
15537 : NTSTATUS status;
15538 :
15539 : /* In parameters */
15540 0 : r.in.Node = _Node;
15541 :
15542 : /* Out parameters */
15543 0 : r.out.Node = _Node;
15544 :
15545 : /* Result */
15546 0 : NDR_ZERO_STRUCT(r.out.result);
15547 :
15548 0 : status = dcerpc_clusapi_CloseNode_r(h, mem_ctx, &r);
15549 0 : if (!NT_STATUS_IS_OK(status)) {
15550 0 : return status;
15551 : }
15552 :
15553 : /* Return variables */
15554 0 : *_Node = *r.out.Node;
15555 :
15556 : /* Return result */
15557 0 : *result = r.out.result;
15558 :
15559 0 : return NT_STATUS_OK;
15560 : }
15561 :
15562 : struct dcerpc_clusapi_GetNodeState_r_state {
15563 : TALLOC_CTX *out_mem_ctx;
15564 : };
15565 :
15566 : static void dcerpc_clusapi_GetNodeState_r_done(struct tevent_req *subreq);
15567 :
15568 0 : struct tevent_req *dcerpc_clusapi_GetNodeState_r_send(TALLOC_CTX *mem_ctx,
15569 : struct tevent_context *ev,
15570 : struct dcerpc_binding_handle *h,
15571 : struct clusapi_GetNodeState *r)
15572 : {
15573 : struct tevent_req *req;
15574 : struct dcerpc_clusapi_GetNodeState_r_state *state;
15575 : struct tevent_req *subreq;
15576 :
15577 0 : req = tevent_req_create(mem_ctx, &state,
15578 : struct dcerpc_clusapi_GetNodeState_r_state);
15579 0 : if (req == NULL) {
15580 0 : return NULL;
15581 : }
15582 :
15583 0 : state->out_mem_ctx = talloc_new(state);
15584 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15585 0 : return tevent_req_post(req, ev);
15586 : }
15587 :
15588 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
15589 : NULL, &ndr_table_clusapi,
15590 0 : NDR_CLUSAPI_GETNODESTATE, state->out_mem_ctx, r);
15591 0 : if (tevent_req_nomem(subreq, req)) {
15592 0 : return tevent_req_post(req, ev);
15593 : }
15594 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNodeState_r_done, req);
15595 :
15596 0 : return req;
15597 : }
15598 :
15599 0 : static void dcerpc_clusapi_GetNodeState_r_done(struct tevent_req *subreq)
15600 : {
15601 0 : struct tevent_req *req =
15602 0 : tevent_req_callback_data(subreq,
15603 : struct tevent_req);
15604 : NTSTATUS status;
15605 :
15606 0 : status = dcerpc_binding_handle_call_recv(subreq);
15607 0 : TALLOC_FREE(subreq);
15608 0 : if (tevent_req_nterror(req, status)) {
15609 0 : return;
15610 : }
15611 :
15612 0 : tevent_req_done(req);
15613 : }
15614 :
15615 0 : NTSTATUS dcerpc_clusapi_GetNodeState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
15616 : {
15617 0 : struct dcerpc_clusapi_GetNodeState_r_state *state =
15618 0 : tevent_req_data(req,
15619 : struct dcerpc_clusapi_GetNodeState_r_state);
15620 : NTSTATUS status;
15621 :
15622 0 : if (tevent_req_is_nterror(req, &status)) {
15623 0 : tevent_req_received(req);
15624 0 : return status;
15625 : }
15626 :
15627 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15628 :
15629 0 : tevent_req_received(req);
15630 0 : return NT_STATUS_OK;
15631 : }
15632 :
15633 0 : NTSTATUS dcerpc_clusapi_GetNodeState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNodeState *r)
15634 : {
15635 : NTSTATUS status;
15636 :
15637 0 : status = dcerpc_binding_handle_call(h,
15638 : NULL, &ndr_table_clusapi,
15639 : NDR_CLUSAPI_GETNODESTATE, mem_ctx, r);
15640 :
15641 0 : return status;
15642 : }
15643 :
15644 : struct dcerpc_clusapi_GetNodeState_state {
15645 : struct clusapi_GetNodeState orig;
15646 : struct clusapi_GetNodeState tmp;
15647 : TALLOC_CTX *out_mem_ctx;
15648 : };
15649 :
15650 : static void dcerpc_clusapi_GetNodeState_done(struct tevent_req *subreq);
15651 :
15652 0 : struct tevent_req *dcerpc_clusapi_GetNodeState_send(TALLOC_CTX *mem_ctx,
15653 : struct tevent_context *ev,
15654 : struct dcerpc_binding_handle *h,
15655 : struct policy_handle _hNode /* [in] */,
15656 : enum clusapi_ClusterNodeState *_State /* [out] [ref] */,
15657 : WERROR *_rpc_status /* [out] [ref] */)
15658 : {
15659 : struct tevent_req *req;
15660 : struct dcerpc_clusapi_GetNodeState_state *state;
15661 : struct tevent_req *subreq;
15662 :
15663 0 : req = tevent_req_create(mem_ctx, &state,
15664 : struct dcerpc_clusapi_GetNodeState_state);
15665 0 : if (req == NULL) {
15666 0 : return NULL;
15667 : }
15668 0 : state->out_mem_ctx = NULL;
15669 :
15670 : /* In parameters */
15671 0 : state->orig.in.hNode = _hNode;
15672 :
15673 : /* Out parameters */
15674 0 : state->orig.out.State = _State;
15675 0 : state->orig.out.rpc_status = _rpc_status;
15676 :
15677 : /* Result */
15678 0 : NDR_ZERO_STRUCT(state->orig.out.result);
15679 :
15680 0 : state->out_mem_ctx = talloc_named_const(state, 0,
15681 : "dcerpc_clusapi_GetNodeState_out_memory");
15682 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15683 0 : return tevent_req_post(req, ev);
15684 : }
15685 :
15686 : /* make a temporary copy, that we pass to the dispatch function */
15687 0 : state->tmp = state->orig;
15688 :
15689 0 : subreq = dcerpc_clusapi_GetNodeState_r_send(state, ev, h, &state->tmp);
15690 0 : if (tevent_req_nomem(subreq, req)) {
15691 0 : return tevent_req_post(req, ev);
15692 : }
15693 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNodeState_done, req);
15694 0 : return req;
15695 : }
15696 :
15697 0 : static void dcerpc_clusapi_GetNodeState_done(struct tevent_req *subreq)
15698 : {
15699 0 : struct tevent_req *req = tevent_req_callback_data(
15700 : subreq, struct tevent_req);
15701 0 : struct dcerpc_clusapi_GetNodeState_state *state = tevent_req_data(
15702 : req, struct dcerpc_clusapi_GetNodeState_state);
15703 : NTSTATUS status;
15704 : TALLOC_CTX *mem_ctx;
15705 :
15706 0 : if (state->out_mem_ctx) {
15707 0 : mem_ctx = state->out_mem_ctx;
15708 : } else {
15709 0 : mem_ctx = state;
15710 : }
15711 :
15712 0 : status = dcerpc_clusapi_GetNodeState_r_recv(subreq, mem_ctx);
15713 0 : TALLOC_FREE(subreq);
15714 0 : if (tevent_req_nterror(req, status)) {
15715 0 : return;
15716 : }
15717 :
15718 : /* Copy out parameters */
15719 0 : *state->orig.out.State = *state->tmp.out.State;
15720 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
15721 :
15722 : /* Copy result */
15723 0 : state->orig.out.result = state->tmp.out.result;
15724 :
15725 : /* Reset temporary structure */
15726 0 : NDR_ZERO_STRUCT(state->tmp);
15727 :
15728 0 : tevent_req_done(req);
15729 : }
15730 :
15731 0 : NTSTATUS dcerpc_clusapi_GetNodeState_recv(struct tevent_req *req,
15732 : TALLOC_CTX *mem_ctx,
15733 : WERROR *result)
15734 : {
15735 0 : struct dcerpc_clusapi_GetNodeState_state *state = tevent_req_data(
15736 : req, struct dcerpc_clusapi_GetNodeState_state);
15737 : NTSTATUS status;
15738 :
15739 0 : if (tevent_req_is_nterror(req, &status)) {
15740 0 : tevent_req_received(req);
15741 0 : return status;
15742 : }
15743 :
15744 : /* Steal possible out parameters to the callers context */
15745 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15746 :
15747 : /* Return result */
15748 0 : *result = state->orig.out.result;
15749 :
15750 0 : tevent_req_received(req);
15751 0 : return NT_STATUS_OK;
15752 : }
15753 :
15754 0 : NTSTATUS dcerpc_clusapi_GetNodeState(struct dcerpc_binding_handle *h,
15755 : TALLOC_CTX *mem_ctx,
15756 : struct policy_handle _hNode /* [in] */,
15757 : enum clusapi_ClusterNodeState *_State /* [out] [ref] */,
15758 : WERROR *_rpc_status /* [out] [ref] */,
15759 : WERROR *result)
15760 : {
15761 : struct clusapi_GetNodeState r;
15762 : NTSTATUS status;
15763 :
15764 : /* In parameters */
15765 0 : r.in.hNode = _hNode;
15766 :
15767 : /* Out parameters */
15768 0 : r.out.State = _State;
15769 0 : r.out.rpc_status = _rpc_status;
15770 :
15771 : /* Result */
15772 0 : NDR_ZERO_STRUCT(r.out.result);
15773 :
15774 0 : status = dcerpc_clusapi_GetNodeState_r(h, mem_ctx, &r);
15775 0 : if (!NT_STATUS_IS_OK(status)) {
15776 0 : return status;
15777 : }
15778 :
15779 : /* Return variables */
15780 0 : *_State = *r.out.State;
15781 0 : *_rpc_status = *r.out.rpc_status;
15782 :
15783 : /* Return result */
15784 0 : *result = r.out.result;
15785 :
15786 0 : return NT_STATUS_OK;
15787 : }
15788 :
15789 : struct dcerpc_clusapi_PauseNode_r_state {
15790 : TALLOC_CTX *out_mem_ctx;
15791 : };
15792 :
15793 : static void dcerpc_clusapi_PauseNode_r_done(struct tevent_req *subreq);
15794 :
15795 0 : struct tevent_req *dcerpc_clusapi_PauseNode_r_send(TALLOC_CTX *mem_ctx,
15796 : struct tevent_context *ev,
15797 : struct dcerpc_binding_handle *h,
15798 : struct clusapi_PauseNode *r)
15799 : {
15800 : struct tevent_req *req;
15801 : struct dcerpc_clusapi_PauseNode_r_state *state;
15802 : struct tevent_req *subreq;
15803 :
15804 0 : req = tevent_req_create(mem_ctx, &state,
15805 : struct dcerpc_clusapi_PauseNode_r_state);
15806 0 : if (req == NULL) {
15807 0 : return NULL;
15808 : }
15809 :
15810 0 : state->out_mem_ctx = talloc_new(state);
15811 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15812 0 : return tevent_req_post(req, ev);
15813 : }
15814 :
15815 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
15816 : NULL, &ndr_table_clusapi,
15817 0 : NDR_CLUSAPI_PAUSENODE, state->out_mem_ctx, r);
15818 0 : if (tevent_req_nomem(subreq, req)) {
15819 0 : return tevent_req_post(req, ev);
15820 : }
15821 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNode_r_done, req);
15822 :
15823 0 : return req;
15824 : }
15825 :
15826 0 : static void dcerpc_clusapi_PauseNode_r_done(struct tevent_req *subreq)
15827 : {
15828 0 : struct tevent_req *req =
15829 0 : tevent_req_callback_data(subreq,
15830 : struct tevent_req);
15831 : NTSTATUS status;
15832 :
15833 0 : status = dcerpc_binding_handle_call_recv(subreq);
15834 0 : TALLOC_FREE(subreq);
15835 0 : if (tevent_req_nterror(req, status)) {
15836 0 : return;
15837 : }
15838 :
15839 0 : tevent_req_done(req);
15840 : }
15841 :
15842 0 : NTSTATUS dcerpc_clusapi_PauseNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
15843 : {
15844 0 : struct dcerpc_clusapi_PauseNode_r_state *state =
15845 0 : tevent_req_data(req,
15846 : struct dcerpc_clusapi_PauseNode_r_state);
15847 : NTSTATUS status;
15848 :
15849 0 : if (tevent_req_is_nterror(req, &status)) {
15850 0 : tevent_req_received(req);
15851 0 : return status;
15852 : }
15853 :
15854 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15855 :
15856 0 : tevent_req_received(req);
15857 0 : return NT_STATUS_OK;
15858 : }
15859 :
15860 0 : NTSTATUS dcerpc_clusapi_PauseNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_PauseNode *r)
15861 : {
15862 : NTSTATUS status;
15863 :
15864 0 : status = dcerpc_binding_handle_call(h,
15865 : NULL, &ndr_table_clusapi,
15866 : NDR_CLUSAPI_PAUSENODE, mem_ctx, r);
15867 :
15868 0 : return status;
15869 : }
15870 :
15871 : struct dcerpc_clusapi_PauseNode_state {
15872 : struct clusapi_PauseNode orig;
15873 : struct clusapi_PauseNode tmp;
15874 : TALLOC_CTX *out_mem_ctx;
15875 : };
15876 :
15877 : static void dcerpc_clusapi_PauseNode_done(struct tevent_req *subreq);
15878 :
15879 0 : struct tevent_req *dcerpc_clusapi_PauseNode_send(TALLOC_CTX *mem_ctx,
15880 : struct tevent_context *ev,
15881 : struct dcerpc_binding_handle *h,
15882 : struct policy_handle _hNode /* [in] */,
15883 : WERROR *_rpc_status /* [out] [ref] */)
15884 : {
15885 : struct tevent_req *req;
15886 : struct dcerpc_clusapi_PauseNode_state *state;
15887 : struct tevent_req *subreq;
15888 :
15889 0 : req = tevent_req_create(mem_ctx, &state,
15890 : struct dcerpc_clusapi_PauseNode_state);
15891 0 : if (req == NULL) {
15892 0 : return NULL;
15893 : }
15894 0 : state->out_mem_ctx = NULL;
15895 :
15896 : /* In parameters */
15897 0 : state->orig.in.hNode = _hNode;
15898 :
15899 : /* Out parameters */
15900 0 : state->orig.out.rpc_status = _rpc_status;
15901 :
15902 : /* Result */
15903 0 : NDR_ZERO_STRUCT(state->orig.out.result);
15904 :
15905 0 : state->out_mem_ctx = talloc_named_const(state, 0,
15906 : "dcerpc_clusapi_PauseNode_out_memory");
15907 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
15908 0 : return tevent_req_post(req, ev);
15909 : }
15910 :
15911 : /* make a temporary copy, that we pass to the dispatch function */
15912 0 : state->tmp = state->orig;
15913 :
15914 0 : subreq = dcerpc_clusapi_PauseNode_r_send(state, ev, h, &state->tmp);
15915 0 : if (tevent_req_nomem(subreq, req)) {
15916 0 : return tevent_req_post(req, ev);
15917 : }
15918 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNode_done, req);
15919 0 : return req;
15920 : }
15921 :
15922 0 : static void dcerpc_clusapi_PauseNode_done(struct tevent_req *subreq)
15923 : {
15924 0 : struct tevent_req *req = tevent_req_callback_data(
15925 : subreq, struct tevent_req);
15926 0 : struct dcerpc_clusapi_PauseNode_state *state = tevent_req_data(
15927 : req, struct dcerpc_clusapi_PauseNode_state);
15928 : NTSTATUS status;
15929 : TALLOC_CTX *mem_ctx;
15930 :
15931 0 : if (state->out_mem_ctx) {
15932 0 : mem_ctx = state->out_mem_ctx;
15933 : } else {
15934 0 : mem_ctx = state;
15935 : }
15936 :
15937 0 : status = dcerpc_clusapi_PauseNode_r_recv(subreq, mem_ctx);
15938 0 : TALLOC_FREE(subreq);
15939 0 : if (tevent_req_nterror(req, status)) {
15940 0 : return;
15941 : }
15942 :
15943 : /* Copy out parameters */
15944 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
15945 :
15946 : /* Copy result */
15947 0 : state->orig.out.result = state->tmp.out.result;
15948 :
15949 : /* Reset temporary structure */
15950 0 : NDR_ZERO_STRUCT(state->tmp);
15951 :
15952 0 : tevent_req_done(req);
15953 : }
15954 :
15955 0 : NTSTATUS dcerpc_clusapi_PauseNode_recv(struct tevent_req *req,
15956 : TALLOC_CTX *mem_ctx,
15957 : WERROR *result)
15958 : {
15959 0 : struct dcerpc_clusapi_PauseNode_state *state = tevent_req_data(
15960 : req, struct dcerpc_clusapi_PauseNode_state);
15961 : NTSTATUS status;
15962 :
15963 0 : if (tevent_req_is_nterror(req, &status)) {
15964 0 : tevent_req_received(req);
15965 0 : return status;
15966 : }
15967 :
15968 : /* Steal possible out parameters to the callers context */
15969 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
15970 :
15971 : /* Return result */
15972 0 : *result = state->orig.out.result;
15973 :
15974 0 : tevent_req_received(req);
15975 0 : return NT_STATUS_OK;
15976 : }
15977 :
15978 0 : NTSTATUS dcerpc_clusapi_PauseNode(struct dcerpc_binding_handle *h,
15979 : TALLOC_CTX *mem_ctx,
15980 : struct policy_handle _hNode /* [in] */,
15981 : WERROR *_rpc_status /* [out] [ref] */,
15982 : WERROR *result)
15983 : {
15984 : struct clusapi_PauseNode r;
15985 : NTSTATUS status;
15986 :
15987 : /* In parameters */
15988 0 : r.in.hNode = _hNode;
15989 :
15990 : /* Out parameters */
15991 0 : r.out.rpc_status = _rpc_status;
15992 :
15993 : /* Result */
15994 0 : NDR_ZERO_STRUCT(r.out.result);
15995 :
15996 0 : status = dcerpc_clusapi_PauseNode_r(h, mem_ctx, &r);
15997 0 : if (!NT_STATUS_IS_OK(status)) {
15998 0 : return status;
15999 : }
16000 :
16001 : /* Return variables */
16002 0 : *_rpc_status = *r.out.rpc_status;
16003 :
16004 : /* Return result */
16005 0 : *result = r.out.result;
16006 :
16007 0 : return NT_STATUS_OK;
16008 : }
16009 :
16010 : struct dcerpc_clusapi_ResumeNode_r_state {
16011 : TALLOC_CTX *out_mem_ctx;
16012 : };
16013 :
16014 : static void dcerpc_clusapi_ResumeNode_r_done(struct tevent_req *subreq);
16015 :
16016 0 : struct tevent_req *dcerpc_clusapi_ResumeNode_r_send(TALLOC_CTX *mem_ctx,
16017 : struct tevent_context *ev,
16018 : struct dcerpc_binding_handle *h,
16019 : struct clusapi_ResumeNode *r)
16020 : {
16021 : struct tevent_req *req;
16022 : struct dcerpc_clusapi_ResumeNode_r_state *state;
16023 : struct tevent_req *subreq;
16024 :
16025 0 : req = tevent_req_create(mem_ctx, &state,
16026 : struct dcerpc_clusapi_ResumeNode_r_state);
16027 0 : if (req == NULL) {
16028 0 : return NULL;
16029 : }
16030 :
16031 0 : state->out_mem_ctx = talloc_new(state);
16032 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16033 0 : return tevent_req_post(req, ev);
16034 : }
16035 :
16036 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
16037 : NULL, &ndr_table_clusapi,
16038 0 : NDR_CLUSAPI_RESUMENODE, state->out_mem_ctx, r);
16039 0 : if (tevent_req_nomem(subreq, req)) {
16040 0 : return tevent_req_post(req, ev);
16041 : }
16042 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResumeNode_r_done, req);
16043 :
16044 0 : return req;
16045 : }
16046 :
16047 0 : static void dcerpc_clusapi_ResumeNode_r_done(struct tevent_req *subreq)
16048 : {
16049 0 : struct tevent_req *req =
16050 0 : tevent_req_callback_data(subreq,
16051 : struct tevent_req);
16052 : NTSTATUS status;
16053 :
16054 0 : status = dcerpc_binding_handle_call_recv(subreq);
16055 0 : TALLOC_FREE(subreq);
16056 0 : if (tevent_req_nterror(req, status)) {
16057 0 : return;
16058 : }
16059 :
16060 0 : tevent_req_done(req);
16061 : }
16062 :
16063 0 : NTSTATUS dcerpc_clusapi_ResumeNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
16064 : {
16065 0 : struct dcerpc_clusapi_ResumeNode_r_state *state =
16066 0 : tevent_req_data(req,
16067 : struct dcerpc_clusapi_ResumeNode_r_state);
16068 : NTSTATUS status;
16069 :
16070 0 : if (tevent_req_is_nterror(req, &status)) {
16071 0 : tevent_req_received(req);
16072 0 : return status;
16073 : }
16074 :
16075 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16076 :
16077 0 : tevent_req_received(req);
16078 0 : return NT_STATUS_OK;
16079 : }
16080 :
16081 0 : NTSTATUS dcerpc_clusapi_ResumeNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ResumeNode *r)
16082 : {
16083 : NTSTATUS status;
16084 :
16085 0 : status = dcerpc_binding_handle_call(h,
16086 : NULL, &ndr_table_clusapi,
16087 : NDR_CLUSAPI_RESUMENODE, mem_ctx, r);
16088 :
16089 0 : return status;
16090 : }
16091 :
16092 : struct dcerpc_clusapi_ResumeNode_state {
16093 : struct clusapi_ResumeNode orig;
16094 : struct clusapi_ResumeNode tmp;
16095 : TALLOC_CTX *out_mem_ctx;
16096 : };
16097 :
16098 : static void dcerpc_clusapi_ResumeNode_done(struct tevent_req *subreq);
16099 :
16100 0 : struct tevent_req *dcerpc_clusapi_ResumeNode_send(TALLOC_CTX *mem_ctx,
16101 : struct tevent_context *ev,
16102 : struct dcerpc_binding_handle *h,
16103 : struct policy_handle _hNode /* [in] */,
16104 : WERROR *_rpc_status /* [out] [ref] */)
16105 : {
16106 : struct tevent_req *req;
16107 : struct dcerpc_clusapi_ResumeNode_state *state;
16108 : struct tevent_req *subreq;
16109 :
16110 0 : req = tevent_req_create(mem_ctx, &state,
16111 : struct dcerpc_clusapi_ResumeNode_state);
16112 0 : if (req == NULL) {
16113 0 : return NULL;
16114 : }
16115 0 : state->out_mem_ctx = NULL;
16116 :
16117 : /* In parameters */
16118 0 : state->orig.in.hNode = _hNode;
16119 :
16120 : /* Out parameters */
16121 0 : state->orig.out.rpc_status = _rpc_status;
16122 :
16123 : /* Result */
16124 0 : NDR_ZERO_STRUCT(state->orig.out.result);
16125 :
16126 0 : state->out_mem_ctx = talloc_named_const(state, 0,
16127 : "dcerpc_clusapi_ResumeNode_out_memory");
16128 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16129 0 : return tevent_req_post(req, ev);
16130 : }
16131 :
16132 : /* make a temporary copy, that we pass to the dispatch function */
16133 0 : state->tmp = state->orig;
16134 :
16135 0 : subreq = dcerpc_clusapi_ResumeNode_r_send(state, ev, h, &state->tmp);
16136 0 : if (tevent_req_nomem(subreq, req)) {
16137 0 : return tevent_req_post(req, ev);
16138 : }
16139 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResumeNode_done, req);
16140 0 : return req;
16141 : }
16142 :
16143 0 : static void dcerpc_clusapi_ResumeNode_done(struct tevent_req *subreq)
16144 : {
16145 0 : struct tevent_req *req = tevent_req_callback_data(
16146 : subreq, struct tevent_req);
16147 0 : struct dcerpc_clusapi_ResumeNode_state *state = tevent_req_data(
16148 : req, struct dcerpc_clusapi_ResumeNode_state);
16149 : NTSTATUS status;
16150 : TALLOC_CTX *mem_ctx;
16151 :
16152 0 : if (state->out_mem_ctx) {
16153 0 : mem_ctx = state->out_mem_ctx;
16154 : } else {
16155 0 : mem_ctx = state;
16156 : }
16157 :
16158 0 : status = dcerpc_clusapi_ResumeNode_r_recv(subreq, mem_ctx);
16159 0 : TALLOC_FREE(subreq);
16160 0 : if (tevent_req_nterror(req, status)) {
16161 0 : return;
16162 : }
16163 :
16164 : /* Copy out parameters */
16165 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
16166 :
16167 : /* Copy result */
16168 0 : state->orig.out.result = state->tmp.out.result;
16169 :
16170 : /* Reset temporary structure */
16171 0 : NDR_ZERO_STRUCT(state->tmp);
16172 :
16173 0 : tevent_req_done(req);
16174 : }
16175 :
16176 0 : NTSTATUS dcerpc_clusapi_ResumeNode_recv(struct tevent_req *req,
16177 : TALLOC_CTX *mem_ctx,
16178 : WERROR *result)
16179 : {
16180 0 : struct dcerpc_clusapi_ResumeNode_state *state = tevent_req_data(
16181 : req, struct dcerpc_clusapi_ResumeNode_state);
16182 : NTSTATUS status;
16183 :
16184 0 : if (tevent_req_is_nterror(req, &status)) {
16185 0 : tevent_req_received(req);
16186 0 : return status;
16187 : }
16188 :
16189 : /* Steal possible out parameters to the callers context */
16190 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16191 :
16192 : /* Return result */
16193 0 : *result = state->orig.out.result;
16194 :
16195 0 : tevent_req_received(req);
16196 0 : return NT_STATUS_OK;
16197 : }
16198 :
16199 0 : NTSTATUS dcerpc_clusapi_ResumeNode(struct dcerpc_binding_handle *h,
16200 : TALLOC_CTX *mem_ctx,
16201 : struct policy_handle _hNode /* [in] */,
16202 : WERROR *_rpc_status /* [out] [ref] */,
16203 : WERROR *result)
16204 : {
16205 : struct clusapi_ResumeNode r;
16206 : NTSTATUS status;
16207 :
16208 : /* In parameters */
16209 0 : r.in.hNode = _hNode;
16210 :
16211 : /* Out parameters */
16212 0 : r.out.rpc_status = _rpc_status;
16213 :
16214 : /* Result */
16215 0 : NDR_ZERO_STRUCT(r.out.result);
16216 :
16217 0 : status = dcerpc_clusapi_ResumeNode_r(h, mem_ctx, &r);
16218 0 : if (!NT_STATUS_IS_OK(status)) {
16219 0 : return status;
16220 : }
16221 :
16222 : /* Return variables */
16223 0 : *_rpc_status = *r.out.rpc_status;
16224 :
16225 : /* Return result */
16226 0 : *result = r.out.result;
16227 :
16228 0 : return NT_STATUS_OK;
16229 : }
16230 :
16231 : struct dcerpc_clusapi_EvictNode_r_state {
16232 : TALLOC_CTX *out_mem_ctx;
16233 : };
16234 :
16235 : static void dcerpc_clusapi_EvictNode_r_done(struct tevent_req *subreq);
16236 :
16237 0 : struct tevent_req *dcerpc_clusapi_EvictNode_r_send(TALLOC_CTX *mem_ctx,
16238 : struct tevent_context *ev,
16239 : struct dcerpc_binding_handle *h,
16240 : struct clusapi_EvictNode *r)
16241 : {
16242 : struct tevent_req *req;
16243 : struct dcerpc_clusapi_EvictNode_r_state *state;
16244 : struct tevent_req *subreq;
16245 :
16246 0 : req = tevent_req_create(mem_ctx, &state,
16247 : struct dcerpc_clusapi_EvictNode_r_state);
16248 0 : if (req == NULL) {
16249 0 : return NULL;
16250 : }
16251 :
16252 0 : state->out_mem_ctx = talloc_new(state);
16253 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16254 0 : return tevent_req_post(req, ev);
16255 : }
16256 :
16257 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
16258 : NULL, &ndr_table_clusapi,
16259 0 : NDR_CLUSAPI_EVICTNODE, state->out_mem_ctx, r);
16260 0 : if (tevent_req_nomem(subreq, req)) {
16261 0 : return tevent_req_post(req, ev);
16262 : }
16263 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EvictNode_r_done, req);
16264 :
16265 0 : return req;
16266 : }
16267 :
16268 0 : static void dcerpc_clusapi_EvictNode_r_done(struct tevent_req *subreq)
16269 : {
16270 0 : struct tevent_req *req =
16271 0 : tevent_req_callback_data(subreq,
16272 : struct tevent_req);
16273 : NTSTATUS status;
16274 :
16275 0 : status = dcerpc_binding_handle_call_recv(subreq);
16276 0 : TALLOC_FREE(subreq);
16277 0 : if (tevent_req_nterror(req, status)) {
16278 0 : return;
16279 : }
16280 :
16281 0 : tevent_req_done(req);
16282 : }
16283 :
16284 0 : NTSTATUS dcerpc_clusapi_EvictNode_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
16285 : {
16286 0 : struct dcerpc_clusapi_EvictNode_r_state *state =
16287 0 : tevent_req_data(req,
16288 : struct dcerpc_clusapi_EvictNode_r_state);
16289 : NTSTATUS status;
16290 :
16291 0 : if (tevent_req_is_nterror(req, &status)) {
16292 0 : tevent_req_received(req);
16293 0 : return status;
16294 : }
16295 :
16296 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16297 :
16298 0 : tevent_req_received(req);
16299 0 : return NT_STATUS_OK;
16300 : }
16301 :
16302 0 : NTSTATUS dcerpc_clusapi_EvictNode_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_EvictNode *r)
16303 : {
16304 : NTSTATUS status;
16305 :
16306 0 : status = dcerpc_binding_handle_call(h,
16307 : NULL, &ndr_table_clusapi,
16308 : NDR_CLUSAPI_EVICTNODE, mem_ctx, r);
16309 :
16310 0 : return status;
16311 : }
16312 :
16313 : struct dcerpc_clusapi_EvictNode_state {
16314 : struct clusapi_EvictNode orig;
16315 : struct clusapi_EvictNode tmp;
16316 : TALLOC_CTX *out_mem_ctx;
16317 : };
16318 :
16319 : static void dcerpc_clusapi_EvictNode_done(struct tevent_req *subreq);
16320 :
16321 0 : struct tevent_req *dcerpc_clusapi_EvictNode_send(TALLOC_CTX *mem_ctx,
16322 : struct tevent_context *ev,
16323 : struct dcerpc_binding_handle *h,
16324 : struct policy_handle _hNode /* [in] */,
16325 : WERROR *_rpc_status /* [out] [ref] */)
16326 : {
16327 : struct tevent_req *req;
16328 : struct dcerpc_clusapi_EvictNode_state *state;
16329 : struct tevent_req *subreq;
16330 :
16331 0 : req = tevent_req_create(mem_ctx, &state,
16332 : struct dcerpc_clusapi_EvictNode_state);
16333 0 : if (req == NULL) {
16334 0 : return NULL;
16335 : }
16336 0 : state->out_mem_ctx = NULL;
16337 :
16338 : /* In parameters */
16339 0 : state->orig.in.hNode = _hNode;
16340 :
16341 : /* Out parameters */
16342 0 : state->orig.out.rpc_status = _rpc_status;
16343 :
16344 : /* Result */
16345 0 : NDR_ZERO_STRUCT(state->orig.out.result);
16346 :
16347 0 : state->out_mem_ctx = talloc_named_const(state, 0,
16348 : "dcerpc_clusapi_EvictNode_out_memory");
16349 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16350 0 : return tevent_req_post(req, ev);
16351 : }
16352 :
16353 : /* make a temporary copy, that we pass to the dispatch function */
16354 0 : state->tmp = state->orig;
16355 :
16356 0 : subreq = dcerpc_clusapi_EvictNode_r_send(state, ev, h, &state->tmp);
16357 0 : if (tevent_req_nomem(subreq, req)) {
16358 0 : return tevent_req_post(req, ev);
16359 : }
16360 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_EvictNode_done, req);
16361 0 : return req;
16362 : }
16363 :
16364 0 : static void dcerpc_clusapi_EvictNode_done(struct tevent_req *subreq)
16365 : {
16366 0 : struct tevent_req *req = tevent_req_callback_data(
16367 : subreq, struct tevent_req);
16368 0 : struct dcerpc_clusapi_EvictNode_state *state = tevent_req_data(
16369 : req, struct dcerpc_clusapi_EvictNode_state);
16370 : NTSTATUS status;
16371 : TALLOC_CTX *mem_ctx;
16372 :
16373 0 : if (state->out_mem_ctx) {
16374 0 : mem_ctx = state->out_mem_ctx;
16375 : } else {
16376 0 : mem_ctx = state;
16377 : }
16378 :
16379 0 : status = dcerpc_clusapi_EvictNode_r_recv(subreq, mem_ctx);
16380 0 : TALLOC_FREE(subreq);
16381 0 : if (tevent_req_nterror(req, status)) {
16382 0 : return;
16383 : }
16384 :
16385 : /* Copy out parameters */
16386 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
16387 :
16388 : /* Copy result */
16389 0 : state->orig.out.result = state->tmp.out.result;
16390 :
16391 : /* Reset temporary structure */
16392 0 : NDR_ZERO_STRUCT(state->tmp);
16393 :
16394 0 : tevent_req_done(req);
16395 : }
16396 :
16397 0 : NTSTATUS dcerpc_clusapi_EvictNode_recv(struct tevent_req *req,
16398 : TALLOC_CTX *mem_ctx,
16399 : WERROR *result)
16400 : {
16401 0 : struct dcerpc_clusapi_EvictNode_state *state = tevent_req_data(
16402 : req, struct dcerpc_clusapi_EvictNode_state);
16403 : NTSTATUS status;
16404 :
16405 0 : if (tevent_req_is_nterror(req, &status)) {
16406 0 : tevent_req_received(req);
16407 0 : return status;
16408 : }
16409 :
16410 : /* Steal possible out parameters to the callers context */
16411 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16412 :
16413 : /* Return result */
16414 0 : *result = state->orig.out.result;
16415 :
16416 0 : tevent_req_received(req);
16417 0 : return NT_STATUS_OK;
16418 : }
16419 :
16420 0 : NTSTATUS dcerpc_clusapi_EvictNode(struct dcerpc_binding_handle *h,
16421 : TALLOC_CTX *mem_ctx,
16422 : struct policy_handle _hNode /* [in] */,
16423 : WERROR *_rpc_status /* [out] [ref] */,
16424 : WERROR *result)
16425 : {
16426 : struct clusapi_EvictNode r;
16427 : NTSTATUS status;
16428 :
16429 : /* In parameters */
16430 0 : r.in.hNode = _hNode;
16431 :
16432 : /* Out parameters */
16433 0 : r.out.rpc_status = _rpc_status;
16434 :
16435 : /* Result */
16436 0 : NDR_ZERO_STRUCT(r.out.result);
16437 :
16438 0 : status = dcerpc_clusapi_EvictNode_r(h, mem_ctx, &r);
16439 0 : if (!NT_STATUS_IS_OK(status)) {
16440 0 : return status;
16441 : }
16442 :
16443 : /* Return variables */
16444 0 : *_rpc_status = *r.out.rpc_status;
16445 :
16446 : /* Return result */
16447 0 : *result = r.out.result;
16448 :
16449 0 : return NT_STATUS_OK;
16450 : }
16451 :
16452 : struct dcerpc_clusapi_NodeResourceControl_r_state {
16453 : TALLOC_CTX *out_mem_ctx;
16454 : };
16455 :
16456 : static void dcerpc_clusapi_NodeResourceControl_r_done(struct tevent_req *subreq);
16457 :
16458 0 : struct tevent_req *dcerpc_clusapi_NodeResourceControl_r_send(TALLOC_CTX *mem_ctx,
16459 : struct tevent_context *ev,
16460 : struct dcerpc_binding_handle *h,
16461 : struct clusapi_NodeResourceControl *r)
16462 : {
16463 : struct tevent_req *req;
16464 : struct dcerpc_clusapi_NodeResourceControl_r_state *state;
16465 : struct tevent_req *subreq;
16466 :
16467 0 : req = tevent_req_create(mem_ctx, &state,
16468 : struct dcerpc_clusapi_NodeResourceControl_r_state);
16469 0 : if (req == NULL) {
16470 0 : return NULL;
16471 : }
16472 :
16473 0 : state->out_mem_ctx = talloc_new(state);
16474 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16475 0 : return tevent_req_post(req, ev);
16476 : }
16477 :
16478 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
16479 : NULL, &ndr_table_clusapi,
16480 0 : NDR_CLUSAPI_NODERESOURCECONTROL, state->out_mem_ctx, r);
16481 0 : if (tevent_req_nomem(subreq, req)) {
16482 0 : return tevent_req_post(req, ev);
16483 : }
16484 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeResourceControl_r_done, req);
16485 :
16486 0 : return req;
16487 : }
16488 :
16489 0 : static void dcerpc_clusapi_NodeResourceControl_r_done(struct tevent_req *subreq)
16490 : {
16491 0 : struct tevent_req *req =
16492 0 : tevent_req_callback_data(subreq,
16493 : struct tevent_req);
16494 : NTSTATUS status;
16495 :
16496 0 : status = dcerpc_binding_handle_call_recv(subreq);
16497 0 : TALLOC_FREE(subreq);
16498 0 : if (tevent_req_nterror(req, status)) {
16499 0 : return;
16500 : }
16501 :
16502 0 : tevent_req_done(req);
16503 : }
16504 :
16505 0 : NTSTATUS dcerpc_clusapi_NodeResourceControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
16506 : {
16507 0 : struct dcerpc_clusapi_NodeResourceControl_r_state *state =
16508 0 : tevent_req_data(req,
16509 : struct dcerpc_clusapi_NodeResourceControl_r_state);
16510 : NTSTATUS status;
16511 :
16512 0 : if (tevent_req_is_nterror(req, &status)) {
16513 0 : tevent_req_received(req);
16514 0 : return status;
16515 : }
16516 :
16517 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16518 :
16519 0 : tevent_req_received(req);
16520 0 : return NT_STATUS_OK;
16521 : }
16522 :
16523 0 : NTSTATUS dcerpc_clusapi_NodeResourceControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeResourceControl *r)
16524 : {
16525 : NTSTATUS status;
16526 :
16527 0 : status = dcerpc_binding_handle_call(h,
16528 : NULL, &ndr_table_clusapi,
16529 : NDR_CLUSAPI_NODERESOURCECONTROL, mem_ctx, r);
16530 :
16531 0 : return status;
16532 : }
16533 :
16534 : struct dcerpc_clusapi_NodeResourceControl_state {
16535 : struct clusapi_NodeResourceControl orig;
16536 : struct clusapi_NodeResourceControl tmp;
16537 : TALLOC_CTX *out_mem_ctx;
16538 : };
16539 :
16540 : static void dcerpc_clusapi_NodeResourceControl_done(struct tevent_req *subreq);
16541 :
16542 0 : struct tevent_req *dcerpc_clusapi_NodeResourceControl_send(TALLOC_CTX *mem_ctx,
16543 : struct tevent_context *ev,
16544 : struct dcerpc_binding_handle *h,
16545 : struct policy_handle _hResource /* [in] */,
16546 : struct policy_handle _hNode /* [in] */,
16547 : uint32_t _dwControlCode /* [in] */,
16548 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
16549 : uint32_t _nInBufferSize /* [in] */,
16550 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
16551 : uint32_t _nOutBufferSize /* [in] */,
16552 : uint32_t *_lpBytesReturned /* [out] [ref] */,
16553 : uint32_t *_lpcbRequired /* [out] [ref] */,
16554 : WERROR *_rpc_status /* [out] [ref] */)
16555 : {
16556 : struct tevent_req *req;
16557 : struct dcerpc_clusapi_NodeResourceControl_state *state;
16558 : struct tevent_req *subreq;
16559 :
16560 0 : req = tevent_req_create(mem_ctx, &state,
16561 : struct dcerpc_clusapi_NodeResourceControl_state);
16562 0 : if (req == NULL) {
16563 0 : return NULL;
16564 : }
16565 0 : state->out_mem_ctx = NULL;
16566 :
16567 : /* In parameters */
16568 0 : state->orig.in.hResource = _hResource;
16569 0 : state->orig.in.hNode = _hNode;
16570 0 : state->orig.in.dwControlCode = _dwControlCode;
16571 0 : state->orig.in.lpInBuffer = _lpInBuffer;
16572 0 : state->orig.in.nInBufferSize = _nInBufferSize;
16573 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
16574 :
16575 : /* Out parameters */
16576 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
16577 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
16578 0 : state->orig.out.lpcbRequired = _lpcbRequired;
16579 0 : state->orig.out.rpc_status = _rpc_status;
16580 :
16581 : /* Result */
16582 0 : NDR_ZERO_STRUCT(state->orig.out.result);
16583 :
16584 0 : state->out_mem_ctx = talloc_named_const(state, 0,
16585 : "dcerpc_clusapi_NodeResourceControl_out_memory");
16586 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16587 0 : return tevent_req_post(req, ev);
16588 : }
16589 :
16590 : /* make a temporary copy, that we pass to the dispatch function */
16591 0 : state->tmp = state->orig;
16592 :
16593 0 : subreq = dcerpc_clusapi_NodeResourceControl_r_send(state, ev, h, &state->tmp);
16594 0 : if (tevent_req_nomem(subreq, req)) {
16595 0 : return tevent_req_post(req, ev);
16596 : }
16597 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeResourceControl_done, req);
16598 0 : return req;
16599 : }
16600 :
16601 0 : static void dcerpc_clusapi_NodeResourceControl_done(struct tevent_req *subreq)
16602 : {
16603 0 : struct tevent_req *req = tevent_req_callback_data(
16604 : subreq, struct tevent_req);
16605 0 : struct dcerpc_clusapi_NodeResourceControl_state *state = tevent_req_data(
16606 : req, struct dcerpc_clusapi_NodeResourceControl_state);
16607 : NTSTATUS status;
16608 : TALLOC_CTX *mem_ctx;
16609 :
16610 0 : if (state->out_mem_ctx) {
16611 0 : mem_ctx = state->out_mem_ctx;
16612 : } else {
16613 0 : mem_ctx = state;
16614 : }
16615 :
16616 0 : status = dcerpc_clusapi_NodeResourceControl_r_recv(subreq, mem_ctx);
16617 0 : TALLOC_FREE(subreq);
16618 0 : if (tevent_req_nterror(req, status)) {
16619 0 : return;
16620 : }
16621 :
16622 : /* Copy out parameters */
16623 : {
16624 : size_t _copy_len_lpOutBuffer;
16625 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
16626 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
16627 0 : return;
16628 : }
16629 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
16630 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
16631 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
16632 : }
16633 : }
16634 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
16635 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
16636 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
16637 :
16638 : /* Copy result */
16639 0 : state->orig.out.result = state->tmp.out.result;
16640 :
16641 : /* Reset temporary structure */
16642 0 : NDR_ZERO_STRUCT(state->tmp);
16643 :
16644 0 : tevent_req_done(req);
16645 : }
16646 :
16647 0 : NTSTATUS dcerpc_clusapi_NodeResourceControl_recv(struct tevent_req *req,
16648 : TALLOC_CTX *mem_ctx,
16649 : WERROR *result)
16650 : {
16651 0 : struct dcerpc_clusapi_NodeResourceControl_state *state = tevent_req_data(
16652 : req, struct dcerpc_clusapi_NodeResourceControl_state);
16653 : NTSTATUS status;
16654 :
16655 0 : if (tevent_req_is_nterror(req, &status)) {
16656 0 : tevent_req_received(req);
16657 0 : return status;
16658 : }
16659 :
16660 : /* Steal possible out parameters to the callers context */
16661 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16662 :
16663 : /* Return result */
16664 0 : *result = state->orig.out.result;
16665 :
16666 0 : tevent_req_received(req);
16667 0 : return NT_STATUS_OK;
16668 : }
16669 :
16670 0 : NTSTATUS dcerpc_clusapi_NodeResourceControl(struct dcerpc_binding_handle *h,
16671 : TALLOC_CTX *mem_ctx,
16672 : struct policy_handle _hResource /* [in] */,
16673 : struct policy_handle _hNode /* [in] */,
16674 : uint32_t _dwControlCode /* [in] */,
16675 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
16676 : uint32_t _nInBufferSize /* [in] */,
16677 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
16678 : uint32_t _nOutBufferSize /* [in] */,
16679 : uint32_t *_lpBytesReturned /* [out] [ref] */,
16680 : uint32_t *_lpcbRequired /* [out] [ref] */,
16681 : WERROR *_rpc_status /* [out] [ref] */,
16682 : WERROR *result)
16683 : {
16684 : struct clusapi_NodeResourceControl r;
16685 : NTSTATUS status;
16686 :
16687 : /* In parameters */
16688 0 : r.in.hResource = _hResource;
16689 0 : r.in.hNode = _hNode;
16690 0 : r.in.dwControlCode = _dwControlCode;
16691 0 : r.in.lpInBuffer = _lpInBuffer;
16692 0 : r.in.nInBufferSize = _nInBufferSize;
16693 0 : r.in.nOutBufferSize = _nOutBufferSize;
16694 :
16695 : /* Out parameters */
16696 0 : r.out.lpOutBuffer = _lpOutBuffer;
16697 0 : r.out.lpBytesReturned = _lpBytesReturned;
16698 0 : r.out.lpcbRequired = _lpcbRequired;
16699 0 : r.out.rpc_status = _rpc_status;
16700 :
16701 : /* Result */
16702 0 : NDR_ZERO_STRUCT(r.out.result);
16703 :
16704 0 : status = dcerpc_clusapi_NodeResourceControl_r(h, mem_ctx, &r);
16705 0 : if (!NT_STATUS_IS_OK(status)) {
16706 0 : return status;
16707 : }
16708 :
16709 : /* Return variables */
16710 : {
16711 : size_t _copy_len_lpOutBuffer;
16712 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
16713 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
16714 : }
16715 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
16716 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
16717 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
16718 : }
16719 : }
16720 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
16721 0 : *_lpcbRequired = *r.out.lpcbRequired;
16722 0 : *_rpc_status = *r.out.rpc_status;
16723 :
16724 : /* Return result */
16725 0 : *result = r.out.result;
16726 :
16727 0 : return NT_STATUS_OK;
16728 : }
16729 :
16730 : struct dcerpc_clusapi_ResourceControl_r_state {
16731 : TALLOC_CTX *out_mem_ctx;
16732 : };
16733 :
16734 : static void dcerpc_clusapi_ResourceControl_r_done(struct tevent_req *subreq);
16735 :
16736 0 : struct tevent_req *dcerpc_clusapi_ResourceControl_r_send(TALLOC_CTX *mem_ctx,
16737 : struct tevent_context *ev,
16738 : struct dcerpc_binding_handle *h,
16739 : struct clusapi_ResourceControl *r)
16740 : {
16741 : struct tevent_req *req;
16742 : struct dcerpc_clusapi_ResourceControl_r_state *state;
16743 : struct tevent_req *subreq;
16744 :
16745 0 : req = tevent_req_create(mem_ctx, &state,
16746 : struct dcerpc_clusapi_ResourceControl_r_state);
16747 0 : if (req == NULL) {
16748 0 : return NULL;
16749 : }
16750 :
16751 0 : state->out_mem_ctx = talloc_new(state);
16752 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16753 0 : return tevent_req_post(req, ev);
16754 : }
16755 :
16756 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
16757 : NULL, &ndr_table_clusapi,
16758 0 : NDR_CLUSAPI_RESOURCECONTROL, state->out_mem_ctx, r);
16759 0 : if (tevent_req_nomem(subreq, req)) {
16760 0 : return tevent_req_post(req, ev);
16761 : }
16762 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResourceControl_r_done, req);
16763 :
16764 0 : return req;
16765 : }
16766 :
16767 0 : static void dcerpc_clusapi_ResourceControl_r_done(struct tevent_req *subreq)
16768 : {
16769 0 : struct tevent_req *req =
16770 0 : tevent_req_callback_data(subreq,
16771 : struct tevent_req);
16772 : NTSTATUS status;
16773 :
16774 0 : status = dcerpc_binding_handle_call_recv(subreq);
16775 0 : TALLOC_FREE(subreq);
16776 0 : if (tevent_req_nterror(req, status)) {
16777 0 : return;
16778 : }
16779 :
16780 0 : tevent_req_done(req);
16781 : }
16782 :
16783 0 : NTSTATUS dcerpc_clusapi_ResourceControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
16784 : {
16785 0 : struct dcerpc_clusapi_ResourceControl_r_state *state =
16786 0 : tevent_req_data(req,
16787 : struct dcerpc_clusapi_ResourceControl_r_state);
16788 : NTSTATUS status;
16789 :
16790 0 : if (tevent_req_is_nterror(req, &status)) {
16791 0 : tevent_req_received(req);
16792 0 : return status;
16793 : }
16794 :
16795 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16796 :
16797 0 : tevent_req_received(req);
16798 0 : return NT_STATUS_OK;
16799 : }
16800 :
16801 0 : NTSTATUS dcerpc_clusapi_ResourceControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ResourceControl *r)
16802 : {
16803 : NTSTATUS status;
16804 :
16805 0 : status = dcerpc_binding_handle_call(h,
16806 : NULL, &ndr_table_clusapi,
16807 : NDR_CLUSAPI_RESOURCECONTROL, mem_ctx, r);
16808 :
16809 0 : return status;
16810 : }
16811 :
16812 : struct dcerpc_clusapi_ResourceControl_state {
16813 : struct clusapi_ResourceControl orig;
16814 : struct clusapi_ResourceControl tmp;
16815 : TALLOC_CTX *out_mem_ctx;
16816 : };
16817 :
16818 : static void dcerpc_clusapi_ResourceControl_done(struct tevent_req *subreq);
16819 :
16820 0 : struct tevent_req *dcerpc_clusapi_ResourceControl_send(TALLOC_CTX *mem_ctx,
16821 : struct tevent_context *ev,
16822 : struct dcerpc_binding_handle *h,
16823 : struct policy_handle _hResource /* [in] */,
16824 : enum clusapi_ResourceControlCode _dwControlCode /* [in] */,
16825 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
16826 : uint32_t _nInBufferSize /* [in] */,
16827 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
16828 : uint32_t _nOutBufferSize /* [in] */,
16829 : uint32_t *_lpBytesReturned /* [out] [ref] */,
16830 : uint32_t *_lpcbRequired /* [out] [ref] */,
16831 : WERROR *_rpc_status /* [out] [ref] */)
16832 : {
16833 : struct tevent_req *req;
16834 : struct dcerpc_clusapi_ResourceControl_state *state;
16835 : struct tevent_req *subreq;
16836 :
16837 0 : req = tevent_req_create(mem_ctx, &state,
16838 : struct dcerpc_clusapi_ResourceControl_state);
16839 0 : if (req == NULL) {
16840 0 : return NULL;
16841 : }
16842 0 : state->out_mem_ctx = NULL;
16843 :
16844 : /* In parameters */
16845 0 : state->orig.in.hResource = _hResource;
16846 0 : state->orig.in.dwControlCode = _dwControlCode;
16847 0 : state->orig.in.lpInBuffer = _lpInBuffer;
16848 0 : state->orig.in.nInBufferSize = _nInBufferSize;
16849 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
16850 :
16851 : /* Out parameters */
16852 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
16853 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
16854 0 : state->orig.out.lpcbRequired = _lpcbRequired;
16855 0 : state->orig.out.rpc_status = _rpc_status;
16856 :
16857 : /* Result */
16858 0 : NDR_ZERO_STRUCT(state->orig.out.result);
16859 :
16860 0 : state->out_mem_ctx = talloc_named_const(state, 0,
16861 : "dcerpc_clusapi_ResourceControl_out_memory");
16862 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
16863 0 : return tevent_req_post(req, ev);
16864 : }
16865 :
16866 : /* make a temporary copy, that we pass to the dispatch function */
16867 0 : state->tmp = state->orig;
16868 :
16869 0 : subreq = dcerpc_clusapi_ResourceControl_r_send(state, ev, h, &state->tmp);
16870 0 : if (tevent_req_nomem(subreq, req)) {
16871 0 : return tevent_req_post(req, ev);
16872 : }
16873 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResourceControl_done, req);
16874 0 : return req;
16875 : }
16876 :
16877 0 : static void dcerpc_clusapi_ResourceControl_done(struct tevent_req *subreq)
16878 : {
16879 0 : struct tevent_req *req = tevent_req_callback_data(
16880 : subreq, struct tevent_req);
16881 0 : struct dcerpc_clusapi_ResourceControl_state *state = tevent_req_data(
16882 : req, struct dcerpc_clusapi_ResourceControl_state);
16883 : NTSTATUS status;
16884 : TALLOC_CTX *mem_ctx;
16885 :
16886 0 : if (state->out_mem_ctx) {
16887 0 : mem_ctx = state->out_mem_ctx;
16888 : } else {
16889 0 : mem_ctx = state;
16890 : }
16891 :
16892 0 : status = dcerpc_clusapi_ResourceControl_r_recv(subreq, mem_ctx);
16893 0 : TALLOC_FREE(subreq);
16894 0 : if (tevent_req_nterror(req, status)) {
16895 0 : return;
16896 : }
16897 :
16898 : /* Copy out parameters */
16899 : {
16900 : size_t _copy_len_lpOutBuffer;
16901 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
16902 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
16903 0 : return;
16904 : }
16905 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
16906 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
16907 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
16908 : }
16909 : }
16910 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
16911 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
16912 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
16913 :
16914 : /* Copy result */
16915 0 : state->orig.out.result = state->tmp.out.result;
16916 :
16917 : /* Reset temporary structure */
16918 0 : NDR_ZERO_STRUCT(state->tmp);
16919 :
16920 0 : tevent_req_done(req);
16921 : }
16922 :
16923 0 : NTSTATUS dcerpc_clusapi_ResourceControl_recv(struct tevent_req *req,
16924 : TALLOC_CTX *mem_ctx,
16925 : WERROR *result)
16926 : {
16927 0 : struct dcerpc_clusapi_ResourceControl_state *state = tevent_req_data(
16928 : req, struct dcerpc_clusapi_ResourceControl_state);
16929 : NTSTATUS status;
16930 :
16931 0 : if (tevent_req_is_nterror(req, &status)) {
16932 0 : tevent_req_received(req);
16933 0 : return status;
16934 : }
16935 :
16936 : /* Steal possible out parameters to the callers context */
16937 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
16938 :
16939 : /* Return result */
16940 0 : *result = state->orig.out.result;
16941 :
16942 0 : tevent_req_received(req);
16943 0 : return NT_STATUS_OK;
16944 : }
16945 :
16946 0 : NTSTATUS dcerpc_clusapi_ResourceControl(struct dcerpc_binding_handle *h,
16947 : TALLOC_CTX *mem_ctx,
16948 : struct policy_handle _hResource /* [in] */,
16949 : enum clusapi_ResourceControlCode _dwControlCode /* [in] */,
16950 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
16951 : uint32_t _nInBufferSize /* [in] */,
16952 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
16953 : uint32_t _nOutBufferSize /* [in] */,
16954 : uint32_t *_lpBytesReturned /* [out] [ref] */,
16955 : uint32_t *_lpcbRequired /* [out] [ref] */,
16956 : WERROR *_rpc_status /* [out] [ref] */,
16957 : WERROR *result)
16958 : {
16959 : struct clusapi_ResourceControl r;
16960 : NTSTATUS status;
16961 :
16962 : /* In parameters */
16963 0 : r.in.hResource = _hResource;
16964 0 : r.in.dwControlCode = _dwControlCode;
16965 0 : r.in.lpInBuffer = _lpInBuffer;
16966 0 : r.in.nInBufferSize = _nInBufferSize;
16967 0 : r.in.nOutBufferSize = _nOutBufferSize;
16968 :
16969 : /* Out parameters */
16970 0 : r.out.lpOutBuffer = _lpOutBuffer;
16971 0 : r.out.lpBytesReturned = _lpBytesReturned;
16972 0 : r.out.lpcbRequired = _lpcbRequired;
16973 0 : r.out.rpc_status = _rpc_status;
16974 :
16975 : /* Result */
16976 0 : NDR_ZERO_STRUCT(r.out.result);
16977 :
16978 0 : status = dcerpc_clusapi_ResourceControl_r(h, mem_ctx, &r);
16979 0 : if (!NT_STATUS_IS_OK(status)) {
16980 0 : return status;
16981 : }
16982 :
16983 : /* Return variables */
16984 : {
16985 : size_t _copy_len_lpOutBuffer;
16986 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
16987 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
16988 : }
16989 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
16990 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
16991 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
16992 : }
16993 : }
16994 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
16995 0 : *_lpcbRequired = *r.out.lpcbRequired;
16996 0 : *_rpc_status = *r.out.rpc_status;
16997 :
16998 : /* Return result */
16999 0 : *result = r.out.result;
17000 :
17001 0 : return NT_STATUS_OK;
17002 : }
17003 :
17004 : struct dcerpc_clusapi_NodeResourceTypeControl_r_state {
17005 : TALLOC_CTX *out_mem_ctx;
17006 : };
17007 :
17008 : static void dcerpc_clusapi_NodeResourceTypeControl_r_done(struct tevent_req *subreq);
17009 :
17010 0 : struct tevent_req *dcerpc_clusapi_NodeResourceTypeControl_r_send(TALLOC_CTX *mem_ctx,
17011 : struct tevent_context *ev,
17012 : struct dcerpc_binding_handle *h,
17013 : struct clusapi_NodeResourceTypeControl *r)
17014 : {
17015 : struct tevent_req *req;
17016 : struct dcerpc_clusapi_NodeResourceTypeControl_r_state *state;
17017 : struct tevent_req *subreq;
17018 :
17019 0 : req = tevent_req_create(mem_ctx, &state,
17020 : struct dcerpc_clusapi_NodeResourceTypeControl_r_state);
17021 0 : if (req == NULL) {
17022 0 : return NULL;
17023 : }
17024 :
17025 0 : state->out_mem_ctx = talloc_new(state);
17026 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17027 0 : return tevent_req_post(req, ev);
17028 : }
17029 :
17030 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
17031 : NULL, &ndr_table_clusapi,
17032 0 : NDR_CLUSAPI_NODERESOURCETYPECONTROL, state->out_mem_ctx, r);
17033 0 : if (tevent_req_nomem(subreq, req)) {
17034 0 : return tevent_req_post(req, ev);
17035 : }
17036 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeResourceTypeControl_r_done, req);
17037 :
17038 0 : return req;
17039 : }
17040 :
17041 0 : static void dcerpc_clusapi_NodeResourceTypeControl_r_done(struct tevent_req *subreq)
17042 : {
17043 0 : struct tevent_req *req =
17044 0 : tevent_req_callback_data(subreq,
17045 : struct tevent_req);
17046 : NTSTATUS status;
17047 :
17048 0 : status = dcerpc_binding_handle_call_recv(subreq);
17049 0 : TALLOC_FREE(subreq);
17050 0 : if (tevent_req_nterror(req, status)) {
17051 0 : return;
17052 : }
17053 :
17054 0 : tevent_req_done(req);
17055 : }
17056 :
17057 0 : NTSTATUS dcerpc_clusapi_NodeResourceTypeControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
17058 : {
17059 0 : struct dcerpc_clusapi_NodeResourceTypeControl_r_state *state =
17060 0 : tevent_req_data(req,
17061 : struct dcerpc_clusapi_NodeResourceTypeControl_r_state);
17062 : NTSTATUS status;
17063 :
17064 0 : if (tevent_req_is_nterror(req, &status)) {
17065 0 : tevent_req_received(req);
17066 0 : return status;
17067 : }
17068 :
17069 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17070 :
17071 0 : tevent_req_received(req);
17072 0 : return NT_STATUS_OK;
17073 : }
17074 :
17075 0 : NTSTATUS dcerpc_clusapi_NodeResourceTypeControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeResourceTypeControl *r)
17076 : {
17077 : NTSTATUS status;
17078 :
17079 0 : status = dcerpc_binding_handle_call(h,
17080 : NULL, &ndr_table_clusapi,
17081 : NDR_CLUSAPI_NODERESOURCETYPECONTROL, mem_ctx, r);
17082 :
17083 0 : return status;
17084 : }
17085 :
17086 : struct dcerpc_clusapi_NodeResourceTypeControl_state {
17087 : struct clusapi_NodeResourceTypeControl orig;
17088 : struct clusapi_NodeResourceTypeControl tmp;
17089 : TALLOC_CTX *out_mem_ctx;
17090 : };
17091 :
17092 : static void dcerpc_clusapi_NodeResourceTypeControl_done(struct tevent_req *subreq);
17093 :
17094 0 : struct tevent_req *dcerpc_clusapi_NodeResourceTypeControl_send(TALLOC_CTX *mem_ctx,
17095 : struct tevent_context *ev,
17096 : struct dcerpc_binding_handle *h,
17097 : struct policy_handle _hCluster /* [in] */,
17098 : const char *_lpszResourceTypeName /* [in] [charset(UTF16),ref] */,
17099 : struct policy_handle _hNode /* [in] */,
17100 : uint32_t _dwControlCode /* [in] */,
17101 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17102 : uint32_t _nInBufferSize /* [in] */,
17103 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17104 : uint32_t _nOutBufferSize /* [in] */,
17105 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17106 : uint32_t *_lpcbRequired /* [out] [ref] */,
17107 : WERROR *_rpc_status /* [out] [ref] */)
17108 : {
17109 : struct tevent_req *req;
17110 : struct dcerpc_clusapi_NodeResourceTypeControl_state *state;
17111 : struct tevent_req *subreq;
17112 :
17113 0 : req = tevent_req_create(mem_ctx, &state,
17114 : struct dcerpc_clusapi_NodeResourceTypeControl_state);
17115 0 : if (req == NULL) {
17116 0 : return NULL;
17117 : }
17118 0 : state->out_mem_ctx = NULL;
17119 :
17120 : /* In parameters */
17121 0 : state->orig.in.hCluster = _hCluster;
17122 0 : state->orig.in.lpszResourceTypeName = _lpszResourceTypeName;
17123 0 : state->orig.in.hNode = _hNode;
17124 0 : state->orig.in.dwControlCode = _dwControlCode;
17125 0 : state->orig.in.lpInBuffer = _lpInBuffer;
17126 0 : state->orig.in.nInBufferSize = _nInBufferSize;
17127 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
17128 :
17129 : /* Out parameters */
17130 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
17131 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
17132 0 : state->orig.out.lpcbRequired = _lpcbRequired;
17133 0 : state->orig.out.rpc_status = _rpc_status;
17134 :
17135 : /* Result */
17136 0 : NDR_ZERO_STRUCT(state->orig.out.result);
17137 :
17138 0 : state->out_mem_ctx = talloc_named_const(state, 0,
17139 : "dcerpc_clusapi_NodeResourceTypeControl_out_memory");
17140 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17141 0 : return tevent_req_post(req, ev);
17142 : }
17143 :
17144 : /* make a temporary copy, that we pass to the dispatch function */
17145 0 : state->tmp = state->orig;
17146 :
17147 0 : subreq = dcerpc_clusapi_NodeResourceTypeControl_r_send(state, ev, h, &state->tmp);
17148 0 : if (tevent_req_nomem(subreq, req)) {
17149 0 : return tevent_req_post(req, ev);
17150 : }
17151 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeResourceTypeControl_done, req);
17152 0 : return req;
17153 : }
17154 :
17155 0 : static void dcerpc_clusapi_NodeResourceTypeControl_done(struct tevent_req *subreq)
17156 : {
17157 0 : struct tevent_req *req = tevent_req_callback_data(
17158 : subreq, struct tevent_req);
17159 0 : struct dcerpc_clusapi_NodeResourceTypeControl_state *state = tevent_req_data(
17160 : req, struct dcerpc_clusapi_NodeResourceTypeControl_state);
17161 : NTSTATUS status;
17162 : TALLOC_CTX *mem_ctx;
17163 :
17164 0 : if (state->out_mem_ctx) {
17165 0 : mem_ctx = state->out_mem_ctx;
17166 : } else {
17167 0 : mem_ctx = state;
17168 : }
17169 :
17170 0 : status = dcerpc_clusapi_NodeResourceTypeControl_r_recv(subreq, mem_ctx);
17171 0 : TALLOC_FREE(subreq);
17172 0 : if (tevent_req_nterror(req, status)) {
17173 0 : return;
17174 : }
17175 :
17176 : /* Copy out parameters */
17177 : {
17178 : size_t _copy_len_lpOutBuffer;
17179 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
17180 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
17181 0 : return;
17182 : }
17183 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
17184 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
17185 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
17186 : }
17187 : }
17188 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
17189 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
17190 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
17191 :
17192 : /* Copy result */
17193 0 : state->orig.out.result = state->tmp.out.result;
17194 :
17195 : /* Reset temporary structure */
17196 0 : NDR_ZERO_STRUCT(state->tmp);
17197 :
17198 0 : tevent_req_done(req);
17199 : }
17200 :
17201 0 : NTSTATUS dcerpc_clusapi_NodeResourceTypeControl_recv(struct tevent_req *req,
17202 : TALLOC_CTX *mem_ctx,
17203 : WERROR *result)
17204 : {
17205 0 : struct dcerpc_clusapi_NodeResourceTypeControl_state *state = tevent_req_data(
17206 : req, struct dcerpc_clusapi_NodeResourceTypeControl_state);
17207 : NTSTATUS status;
17208 :
17209 0 : if (tevent_req_is_nterror(req, &status)) {
17210 0 : tevent_req_received(req);
17211 0 : return status;
17212 : }
17213 :
17214 : /* Steal possible out parameters to the callers context */
17215 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17216 :
17217 : /* Return result */
17218 0 : *result = state->orig.out.result;
17219 :
17220 0 : tevent_req_received(req);
17221 0 : return NT_STATUS_OK;
17222 : }
17223 :
17224 0 : NTSTATUS dcerpc_clusapi_NodeResourceTypeControl(struct dcerpc_binding_handle *h,
17225 : TALLOC_CTX *mem_ctx,
17226 : struct policy_handle _hCluster /* [in] */,
17227 : const char *_lpszResourceTypeName /* [in] [charset(UTF16),ref] */,
17228 : struct policy_handle _hNode /* [in] */,
17229 : uint32_t _dwControlCode /* [in] */,
17230 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17231 : uint32_t _nInBufferSize /* [in] */,
17232 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17233 : uint32_t _nOutBufferSize /* [in] */,
17234 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17235 : uint32_t *_lpcbRequired /* [out] [ref] */,
17236 : WERROR *_rpc_status /* [out] [ref] */,
17237 : WERROR *result)
17238 : {
17239 : struct clusapi_NodeResourceTypeControl r;
17240 : NTSTATUS status;
17241 :
17242 : /* In parameters */
17243 0 : r.in.hCluster = _hCluster;
17244 0 : r.in.lpszResourceTypeName = _lpszResourceTypeName;
17245 0 : r.in.hNode = _hNode;
17246 0 : r.in.dwControlCode = _dwControlCode;
17247 0 : r.in.lpInBuffer = _lpInBuffer;
17248 0 : r.in.nInBufferSize = _nInBufferSize;
17249 0 : r.in.nOutBufferSize = _nOutBufferSize;
17250 :
17251 : /* Out parameters */
17252 0 : r.out.lpOutBuffer = _lpOutBuffer;
17253 0 : r.out.lpBytesReturned = _lpBytesReturned;
17254 0 : r.out.lpcbRequired = _lpcbRequired;
17255 0 : r.out.rpc_status = _rpc_status;
17256 :
17257 : /* Result */
17258 0 : NDR_ZERO_STRUCT(r.out.result);
17259 :
17260 0 : status = dcerpc_clusapi_NodeResourceTypeControl_r(h, mem_ctx, &r);
17261 0 : if (!NT_STATUS_IS_OK(status)) {
17262 0 : return status;
17263 : }
17264 :
17265 : /* Return variables */
17266 : {
17267 : size_t _copy_len_lpOutBuffer;
17268 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
17269 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
17270 : }
17271 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
17272 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
17273 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
17274 : }
17275 : }
17276 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
17277 0 : *_lpcbRequired = *r.out.lpcbRequired;
17278 0 : *_rpc_status = *r.out.rpc_status;
17279 :
17280 : /* Return result */
17281 0 : *result = r.out.result;
17282 :
17283 0 : return NT_STATUS_OK;
17284 : }
17285 :
17286 : struct dcerpc_clusapi_ResourceTypeControl_r_state {
17287 : TALLOC_CTX *out_mem_ctx;
17288 : };
17289 :
17290 : static void dcerpc_clusapi_ResourceTypeControl_r_done(struct tevent_req *subreq);
17291 :
17292 0 : struct tevent_req *dcerpc_clusapi_ResourceTypeControl_r_send(TALLOC_CTX *mem_ctx,
17293 : struct tevent_context *ev,
17294 : struct dcerpc_binding_handle *h,
17295 : struct clusapi_ResourceTypeControl *r)
17296 : {
17297 : struct tevent_req *req;
17298 : struct dcerpc_clusapi_ResourceTypeControl_r_state *state;
17299 : struct tevent_req *subreq;
17300 :
17301 0 : req = tevent_req_create(mem_ctx, &state,
17302 : struct dcerpc_clusapi_ResourceTypeControl_r_state);
17303 0 : if (req == NULL) {
17304 0 : return NULL;
17305 : }
17306 :
17307 0 : state->out_mem_ctx = talloc_new(state);
17308 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17309 0 : return tevent_req_post(req, ev);
17310 : }
17311 :
17312 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
17313 : NULL, &ndr_table_clusapi,
17314 0 : NDR_CLUSAPI_RESOURCETYPECONTROL, state->out_mem_ctx, r);
17315 0 : if (tevent_req_nomem(subreq, req)) {
17316 0 : return tevent_req_post(req, ev);
17317 : }
17318 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResourceTypeControl_r_done, req);
17319 :
17320 0 : return req;
17321 : }
17322 :
17323 0 : static void dcerpc_clusapi_ResourceTypeControl_r_done(struct tevent_req *subreq)
17324 : {
17325 0 : struct tevent_req *req =
17326 0 : tevent_req_callback_data(subreq,
17327 : struct tevent_req);
17328 : NTSTATUS status;
17329 :
17330 0 : status = dcerpc_binding_handle_call_recv(subreq);
17331 0 : TALLOC_FREE(subreq);
17332 0 : if (tevent_req_nterror(req, status)) {
17333 0 : return;
17334 : }
17335 :
17336 0 : tevent_req_done(req);
17337 : }
17338 :
17339 0 : NTSTATUS dcerpc_clusapi_ResourceTypeControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
17340 : {
17341 0 : struct dcerpc_clusapi_ResourceTypeControl_r_state *state =
17342 0 : tevent_req_data(req,
17343 : struct dcerpc_clusapi_ResourceTypeControl_r_state);
17344 : NTSTATUS status;
17345 :
17346 0 : if (tevent_req_is_nterror(req, &status)) {
17347 0 : tevent_req_received(req);
17348 0 : return status;
17349 : }
17350 :
17351 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17352 :
17353 0 : tevent_req_received(req);
17354 0 : return NT_STATUS_OK;
17355 : }
17356 :
17357 0 : NTSTATUS dcerpc_clusapi_ResourceTypeControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ResourceTypeControl *r)
17358 : {
17359 : NTSTATUS status;
17360 :
17361 0 : status = dcerpc_binding_handle_call(h,
17362 : NULL, &ndr_table_clusapi,
17363 : NDR_CLUSAPI_RESOURCETYPECONTROL, mem_ctx, r);
17364 :
17365 0 : return status;
17366 : }
17367 :
17368 : struct dcerpc_clusapi_ResourceTypeControl_state {
17369 : struct clusapi_ResourceTypeControl orig;
17370 : struct clusapi_ResourceTypeControl tmp;
17371 : TALLOC_CTX *out_mem_ctx;
17372 : };
17373 :
17374 : static void dcerpc_clusapi_ResourceTypeControl_done(struct tevent_req *subreq);
17375 :
17376 0 : struct tevent_req *dcerpc_clusapi_ResourceTypeControl_send(TALLOC_CTX *mem_ctx,
17377 : struct tevent_context *ev,
17378 : struct dcerpc_binding_handle *h,
17379 : struct policy_handle _hCluster /* [in] */,
17380 : const char *_lpszResourceTypeName /* [in] [charset(UTF16),ref] */,
17381 : enum clusapi_ResourceTypeControlCode _dwControlCode /* [in] */,
17382 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17383 : uint32_t _nInBufferSize /* [in] */,
17384 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17385 : uint32_t _nOutBufferSize /* [in] */,
17386 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17387 : uint32_t *_lpcbRequired /* [out] [ref] */,
17388 : WERROR *_rpc_status /* [out] [ref] */)
17389 : {
17390 : struct tevent_req *req;
17391 : struct dcerpc_clusapi_ResourceTypeControl_state *state;
17392 : struct tevent_req *subreq;
17393 :
17394 0 : req = tevent_req_create(mem_ctx, &state,
17395 : struct dcerpc_clusapi_ResourceTypeControl_state);
17396 0 : if (req == NULL) {
17397 0 : return NULL;
17398 : }
17399 0 : state->out_mem_ctx = NULL;
17400 :
17401 : /* In parameters */
17402 0 : state->orig.in.hCluster = _hCluster;
17403 0 : state->orig.in.lpszResourceTypeName = _lpszResourceTypeName;
17404 0 : state->orig.in.dwControlCode = _dwControlCode;
17405 0 : state->orig.in.lpInBuffer = _lpInBuffer;
17406 0 : state->orig.in.nInBufferSize = _nInBufferSize;
17407 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
17408 :
17409 : /* Out parameters */
17410 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
17411 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
17412 0 : state->orig.out.lpcbRequired = _lpcbRequired;
17413 0 : state->orig.out.rpc_status = _rpc_status;
17414 :
17415 : /* Result */
17416 0 : NDR_ZERO_STRUCT(state->orig.out.result);
17417 :
17418 0 : state->out_mem_ctx = talloc_named_const(state, 0,
17419 : "dcerpc_clusapi_ResourceTypeControl_out_memory");
17420 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17421 0 : return tevent_req_post(req, ev);
17422 : }
17423 :
17424 : /* make a temporary copy, that we pass to the dispatch function */
17425 0 : state->tmp = state->orig;
17426 :
17427 0 : subreq = dcerpc_clusapi_ResourceTypeControl_r_send(state, ev, h, &state->tmp);
17428 0 : if (tevent_req_nomem(subreq, req)) {
17429 0 : return tevent_req_post(req, ev);
17430 : }
17431 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResourceTypeControl_done, req);
17432 0 : return req;
17433 : }
17434 :
17435 0 : static void dcerpc_clusapi_ResourceTypeControl_done(struct tevent_req *subreq)
17436 : {
17437 0 : struct tevent_req *req = tevent_req_callback_data(
17438 : subreq, struct tevent_req);
17439 0 : struct dcerpc_clusapi_ResourceTypeControl_state *state = tevent_req_data(
17440 : req, struct dcerpc_clusapi_ResourceTypeControl_state);
17441 : NTSTATUS status;
17442 : TALLOC_CTX *mem_ctx;
17443 :
17444 0 : if (state->out_mem_ctx) {
17445 0 : mem_ctx = state->out_mem_ctx;
17446 : } else {
17447 0 : mem_ctx = state;
17448 : }
17449 :
17450 0 : status = dcerpc_clusapi_ResourceTypeControl_r_recv(subreq, mem_ctx);
17451 0 : TALLOC_FREE(subreq);
17452 0 : if (tevent_req_nterror(req, status)) {
17453 0 : return;
17454 : }
17455 :
17456 : /* Copy out parameters */
17457 : {
17458 : size_t _copy_len_lpOutBuffer;
17459 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
17460 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
17461 0 : return;
17462 : }
17463 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
17464 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
17465 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
17466 : }
17467 : }
17468 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
17469 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
17470 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
17471 :
17472 : /* Copy result */
17473 0 : state->orig.out.result = state->tmp.out.result;
17474 :
17475 : /* Reset temporary structure */
17476 0 : NDR_ZERO_STRUCT(state->tmp);
17477 :
17478 0 : tevent_req_done(req);
17479 : }
17480 :
17481 0 : NTSTATUS dcerpc_clusapi_ResourceTypeControl_recv(struct tevent_req *req,
17482 : TALLOC_CTX *mem_ctx,
17483 : WERROR *result)
17484 : {
17485 0 : struct dcerpc_clusapi_ResourceTypeControl_state *state = tevent_req_data(
17486 : req, struct dcerpc_clusapi_ResourceTypeControl_state);
17487 : NTSTATUS status;
17488 :
17489 0 : if (tevent_req_is_nterror(req, &status)) {
17490 0 : tevent_req_received(req);
17491 0 : return status;
17492 : }
17493 :
17494 : /* Steal possible out parameters to the callers context */
17495 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17496 :
17497 : /* Return result */
17498 0 : *result = state->orig.out.result;
17499 :
17500 0 : tevent_req_received(req);
17501 0 : return NT_STATUS_OK;
17502 : }
17503 :
17504 0 : NTSTATUS dcerpc_clusapi_ResourceTypeControl(struct dcerpc_binding_handle *h,
17505 : TALLOC_CTX *mem_ctx,
17506 : struct policy_handle _hCluster /* [in] */,
17507 : const char *_lpszResourceTypeName /* [in] [charset(UTF16),ref] */,
17508 : enum clusapi_ResourceTypeControlCode _dwControlCode /* [in] */,
17509 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17510 : uint32_t _nInBufferSize /* [in] */,
17511 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17512 : uint32_t _nOutBufferSize /* [in] */,
17513 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17514 : uint32_t *_lpcbRequired /* [out] [ref] */,
17515 : WERROR *_rpc_status /* [out] [ref] */,
17516 : WERROR *result)
17517 : {
17518 : struct clusapi_ResourceTypeControl r;
17519 : NTSTATUS status;
17520 :
17521 : /* In parameters */
17522 0 : r.in.hCluster = _hCluster;
17523 0 : r.in.lpszResourceTypeName = _lpszResourceTypeName;
17524 0 : r.in.dwControlCode = _dwControlCode;
17525 0 : r.in.lpInBuffer = _lpInBuffer;
17526 0 : r.in.nInBufferSize = _nInBufferSize;
17527 0 : r.in.nOutBufferSize = _nOutBufferSize;
17528 :
17529 : /* Out parameters */
17530 0 : r.out.lpOutBuffer = _lpOutBuffer;
17531 0 : r.out.lpBytesReturned = _lpBytesReturned;
17532 0 : r.out.lpcbRequired = _lpcbRequired;
17533 0 : r.out.rpc_status = _rpc_status;
17534 :
17535 : /* Result */
17536 0 : NDR_ZERO_STRUCT(r.out.result);
17537 :
17538 0 : status = dcerpc_clusapi_ResourceTypeControl_r(h, mem_ctx, &r);
17539 0 : if (!NT_STATUS_IS_OK(status)) {
17540 0 : return status;
17541 : }
17542 :
17543 : /* Return variables */
17544 : {
17545 : size_t _copy_len_lpOutBuffer;
17546 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
17547 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
17548 : }
17549 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
17550 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
17551 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
17552 : }
17553 : }
17554 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
17555 0 : *_lpcbRequired = *r.out.lpcbRequired;
17556 0 : *_rpc_status = *r.out.rpc_status;
17557 :
17558 : /* Return result */
17559 0 : *result = r.out.result;
17560 :
17561 0 : return NT_STATUS_OK;
17562 : }
17563 :
17564 : struct dcerpc_clusapi_NodeGroupControl_r_state {
17565 : TALLOC_CTX *out_mem_ctx;
17566 : };
17567 :
17568 : static void dcerpc_clusapi_NodeGroupControl_r_done(struct tevent_req *subreq);
17569 :
17570 0 : struct tevent_req *dcerpc_clusapi_NodeGroupControl_r_send(TALLOC_CTX *mem_ctx,
17571 : struct tevent_context *ev,
17572 : struct dcerpc_binding_handle *h,
17573 : struct clusapi_NodeGroupControl *r)
17574 : {
17575 : struct tevent_req *req;
17576 : struct dcerpc_clusapi_NodeGroupControl_r_state *state;
17577 : struct tevent_req *subreq;
17578 :
17579 0 : req = tevent_req_create(mem_ctx, &state,
17580 : struct dcerpc_clusapi_NodeGroupControl_r_state);
17581 0 : if (req == NULL) {
17582 0 : return NULL;
17583 : }
17584 :
17585 0 : state->out_mem_ctx = talloc_new(state);
17586 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17587 0 : return tevent_req_post(req, ev);
17588 : }
17589 :
17590 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
17591 : NULL, &ndr_table_clusapi,
17592 0 : NDR_CLUSAPI_NODEGROUPCONTROL, state->out_mem_ctx, r);
17593 0 : if (tevent_req_nomem(subreq, req)) {
17594 0 : return tevent_req_post(req, ev);
17595 : }
17596 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeGroupControl_r_done, req);
17597 :
17598 0 : return req;
17599 : }
17600 :
17601 0 : static void dcerpc_clusapi_NodeGroupControl_r_done(struct tevent_req *subreq)
17602 : {
17603 0 : struct tevent_req *req =
17604 0 : tevent_req_callback_data(subreq,
17605 : struct tevent_req);
17606 : NTSTATUS status;
17607 :
17608 0 : status = dcerpc_binding_handle_call_recv(subreq);
17609 0 : TALLOC_FREE(subreq);
17610 0 : if (tevent_req_nterror(req, status)) {
17611 0 : return;
17612 : }
17613 :
17614 0 : tevent_req_done(req);
17615 : }
17616 :
17617 0 : NTSTATUS dcerpc_clusapi_NodeGroupControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
17618 : {
17619 0 : struct dcerpc_clusapi_NodeGroupControl_r_state *state =
17620 0 : tevent_req_data(req,
17621 : struct dcerpc_clusapi_NodeGroupControl_r_state);
17622 : NTSTATUS status;
17623 :
17624 0 : if (tevent_req_is_nterror(req, &status)) {
17625 0 : tevent_req_received(req);
17626 0 : return status;
17627 : }
17628 :
17629 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17630 :
17631 0 : tevent_req_received(req);
17632 0 : return NT_STATUS_OK;
17633 : }
17634 :
17635 0 : NTSTATUS dcerpc_clusapi_NodeGroupControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeGroupControl *r)
17636 : {
17637 : NTSTATUS status;
17638 :
17639 0 : status = dcerpc_binding_handle_call(h,
17640 : NULL, &ndr_table_clusapi,
17641 : NDR_CLUSAPI_NODEGROUPCONTROL, mem_ctx, r);
17642 :
17643 0 : return status;
17644 : }
17645 :
17646 : struct dcerpc_clusapi_NodeGroupControl_state {
17647 : struct clusapi_NodeGroupControl orig;
17648 : struct clusapi_NodeGroupControl tmp;
17649 : TALLOC_CTX *out_mem_ctx;
17650 : };
17651 :
17652 : static void dcerpc_clusapi_NodeGroupControl_done(struct tevent_req *subreq);
17653 :
17654 0 : struct tevent_req *dcerpc_clusapi_NodeGroupControl_send(TALLOC_CTX *mem_ctx,
17655 : struct tevent_context *ev,
17656 : struct dcerpc_binding_handle *h,
17657 : struct policy_handle _hGroup /* [in] */,
17658 : struct policy_handle _hNode /* [in] */,
17659 : uint32_t _dwControlCode /* [in] */,
17660 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17661 : uint32_t _nInBufferSize /* [in] */,
17662 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17663 : uint32_t _nOutBufferSize /* [in] */,
17664 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17665 : uint32_t *_lpcbRequired /* [out] [ref] */,
17666 : WERROR *_rpc_status /* [out] [ref] */)
17667 : {
17668 : struct tevent_req *req;
17669 : struct dcerpc_clusapi_NodeGroupControl_state *state;
17670 : struct tevent_req *subreq;
17671 :
17672 0 : req = tevent_req_create(mem_ctx, &state,
17673 : struct dcerpc_clusapi_NodeGroupControl_state);
17674 0 : if (req == NULL) {
17675 0 : return NULL;
17676 : }
17677 0 : state->out_mem_ctx = NULL;
17678 :
17679 : /* In parameters */
17680 0 : state->orig.in.hGroup = _hGroup;
17681 0 : state->orig.in.hNode = _hNode;
17682 0 : state->orig.in.dwControlCode = _dwControlCode;
17683 0 : state->orig.in.lpInBuffer = _lpInBuffer;
17684 0 : state->orig.in.nInBufferSize = _nInBufferSize;
17685 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
17686 :
17687 : /* Out parameters */
17688 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
17689 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
17690 0 : state->orig.out.lpcbRequired = _lpcbRequired;
17691 0 : state->orig.out.rpc_status = _rpc_status;
17692 :
17693 : /* Result */
17694 0 : NDR_ZERO_STRUCT(state->orig.out.result);
17695 :
17696 0 : state->out_mem_ctx = talloc_named_const(state, 0,
17697 : "dcerpc_clusapi_NodeGroupControl_out_memory");
17698 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17699 0 : return tevent_req_post(req, ev);
17700 : }
17701 :
17702 : /* make a temporary copy, that we pass to the dispatch function */
17703 0 : state->tmp = state->orig;
17704 :
17705 0 : subreq = dcerpc_clusapi_NodeGroupControl_r_send(state, ev, h, &state->tmp);
17706 0 : if (tevent_req_nomem(subreq, req)) {
17707 0 : return tevent_req_post(req, ev);
17708 : }
17709 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeGroupControl_done, req);
17710 0 : return req;
17711 : }
17712 :
17713 0 : static void dcerpc_clusapi_NodeGroupControl_done(struct tevent_req *subreq)
17714 : {
17715 0 : struct tevent_req *req = tevent_req_callback_data(
17716 : subreq, struct tevent_req);
17717 0 : struct dcerpc_clusapi_NodeGroupControl_state *state = tevent_req_data(
17718 : req, struct dcerpc_clusapi_NodeGroupControl_state);
17719 : NTSTATUS status;
17720 : TALLOC_CTX *mem_ctx;
17721 :
17722 0 : if (state->out_mem_ctx) {
17723 0 : mem_ctx = state->out_mem_ctx;
17724 : } else {
17725 0 : mem_ctx = state;
17726 : }
17727 :
17728 0 : status = dcerpc_clusapi_NodeGroupControl_r_recv(subreq, mem_ctx);
17729 0 : TALLOC_FREE(subreq);
17730 0 : if (tevent_req_nterror(req, status)) {
17731 0 : return;
17732 : }
17733 :
17734 : /* Copy out parameters */
17735 : {
17736 : size_t _copy_len_lpOutBuffer;
17737 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
17738 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
17739 0 : return;
17740 : }
17741 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
17742 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
17743 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
17744 : }
17745 : }
17746 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
17747 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
17748 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
17749 :
17750 : /* Copy result */
17751 0 : state->orig.out.result = state->tmp.out.result;
17752 :
17753 : /* Reset temporary structure */
17754 0 : NDR_ZERO_STRUCT(state->tmp);
17755 :
17756 0 : tevent_req_done(req);
17757 : }
17758 :
17759 0 : NTSTATUS dcerpc_clusapi_NodeGroupControl_recv(struct tevent_req *req,
17760 : TALLOC_CTX *mem_ctx,
17761 : WERROR *result)
17762 : {
17763 0 : struct dcerpc_clusapi_NodeGroupControl_state *state = tevent_req_data(
17764 : req, struct dcerpc_clusapi_NodeGroupControl_state);
17765 : NTSTATUS status;
17766 :
17767 0 : if (tevent_req_is_nterror(req, &status)) {
17768 0 : tevent_req_received(req);
17769 0 : return status;
17770 : }
17771 :
17772 : /* Steal possible out parameters to the callers context */
17773 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17774 :
17775 : /* Return result */
17776 0 : *result = state->orig.out.result;
17777 :
17778 0 : tevent_req_received(req);
17779 0 : return NT_STATUS_OK;
17780 : }
17781 :
17782 0 : NTSTATUS dcerpc_clusapi_NodeGroupControl(struct dcerpc_binding_handle *h,
17783 : TALLOC_CTX *mem_ctx,
17784 : struct policy_handle _hGroup /* [in] */,
17785 : struct policy_handle _hNode /* [in] */,
17786 : uint32_t _dwControlCode /* [in] */,
17787 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17788 : uint32_t _nInBufferSize /* [in] */,
17789 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17790 : uint32_t _nOutBufferSize /* [in] */,
17791 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17792 : uint32_t *_lpcbRequired /* [out] [ref] */,
17793 : WERROR *_rpc_status /* [out] [ref] */,
17794 : WERROR *result)
17795 : {
17796 : struct clusapi_NodeGroupControl r;
17797 : NTSTATUS status;
17798 :
17799 : /* In parameters */
17800 0 : r.in.hGroup = _hGroup;
17801 0 : r.in.hNode = _hNode;
17802 0 : r.in.dwControlCode = _dwControlCode;
17803 0 : r.in.lpInBuffer = _lpInBuffer;
17804 0 : r.in.nInBufferSize = _nInBufferSize;
17805 0 : r.in.nOutBufferSize = _nOutBufferSize;
17806 :
17807 : /* Out parameters */
17808 0 : r.out.lpOutBuffer = _lpOutBuffer;
17809 0 : r.out.lpBytesReturned = _lpBytesReturned;
17810 0 : r.out.lpcbRequired = _lpcbRequired;
17811 0 : r.out.rpc_status = _rpc_status;
17812 :
17813 : /* Result */
17814 0 : NDR_ZERO_STRUCT(r.out.result);
17815 :
17816 0 : status = dcerpc_clusapi_NodeGroupControl_r(h, mem_ctx, &r);
17817 0 : if (!NT_STATUS_IS_OK(status)) {
17818 0 : return status;
17819 : }
17820 :
17821 : /* Return variables */
17822 : {
17823 : size_t _copy_len_lpOutBuffer;
17824 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
17825 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
17826 : }
17827 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
17828 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
17829 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
17830 : }
17831 : }
17832 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
17833 0 : *_lpcbRequired = *r.out.lpcbRequired;
17834 0 : *_rpc_status = *r.out.rpc_status;
17835 :
17836 : /* Return result */
17837 0 : *result = r.out.result;
17838 :
17839 0 : return NT_STATUS_OK;
17840 : }
17841 :
17842 : struct dcerpc_clusapi_GroupControl_r_state {
17843 : TALLOC_CTX *out_mem_ctx;
17844 : };
17845 :
17846 : static void dcerpc_clusapi_GroupControl_r_done(struct tevent_req *subreq);
17847 :
17848 0 : struct tevent_req *dcerpc_clusapi_GroupControl_r_send(TALLOC_CTX *mem_ctx,
17849 : struct tevent_context *ev,
17850 : struct dcerpc_binding_handle *h,
17851 : struct clusapi_GroupControl *r)
17852 : {
17853 : struct tevent_req *req;
17854 : struct dcerpc_clusapi_GroupControl_r_state *state;
17855 : struct tevent_req *subreq;
17856 :
17857 0 : req = tevent_req_create(mem_ctx, &state,
17858 : struct dcerpc_clusapi_GroupControl_r_state);
17859 0 : if (req == NULL) {
17860 0 : return NULL;
17861 : }
17862 :
17863 0 : state->out_mem_ctx = talloc_new(state);
17864 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17865 0 : return tevent_req_post(req, ev);
17866 : }
17867 :
17868 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
17869 : NULL, &ndr_table_clusapi,
17870 0 : NDR_CLUSAPI_GROUPCONTROL, state->out_mem_ctx, r);
17871 0 : if (tevent_req_nomem(subreq, req)) {
17872 0 : return tevent_req_post(req, ev);
17873 : }
17874 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GroupControl_r_done, req);
17875 :
17876 0 : return req;
17877 : }
17878 :
17879 0 : static void dcerpc_clusapi_GroupControl_r_done(struct tevent_req *subreq)
17880 : {
17881 0 : struct tevent_req *req =
17882 0 : tevent_req_callback_data(subreq,
17883 : struct tevent_req);
17884 : NTSTATUS status;
17885 :
17886 0 : status = dcerpc_binding_handle_call_recv(subreq);
17887 0 : TALLOC_FREE(subreq);
17888 0 : if (tevent_req_nterror(req, status)) {
17889 0 : return;
17890 : }
17891 :
17892 0 : tevent_req_done(req);
17893 : }
17894 :
17895 0 : NTSTATUS dcerpc_clusapi_GroupControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
17896 : {
17897 0 : struct dcerpc_clusapi_GroupControl_r_state *state =
17898 0 : tevent_req_data(req,
17899 : struct dcerpc_clusapi_GroupControl_r_state);
17900 : NTSTATUS status;
17901 :
17902 0 : if (tevent_req_is_nterror(req, &status)) {
17903 0 : tevent_req_received(req);
17904 0 : return status;
17905 : }
17906 :
17907 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
17908 :
17909 0 : tevent_req_received(req);
17910 0 : return NT_STATUS_OK;
17911 : }
17912 :
17913 0 : NTSTATUS dcerpc_clusapi_GroupControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GroupControl *r)
17914 : {
17915 : NTSTATUS status;
17916 :
17917 0 : status = dcerpc_binding_handle_call(h,
17918 : NULL, &ndr_table_clusapi,
17919 : NDR_CLUSAPI_GROUPCONTROL, mem_ctx, r);
17920 :
17921 0 : return status;
17922 : }
17923 :
17924 : struct dcerpc_clusapi_GroupControl_state {
17925 : struct clusapi_GroupControl orig;
17926 : struct clusapi_GroupControl tmp;
17927 : TALLOC_CTX *out_mem_ctx;
17928 : };
17929 :
17930 : static void dcerpc_clusapi_GroupControl_done(struct tevent_req *subreq);
17931 :
17932 0 : struct tevent_req *dcerpc_clusapi_GroupControl_send(TALLOC_CTX *mem_ctx,
17933 : struct tevent_context *ev,
17934 : struct dcerpc_binding_handle *h,
17935 : struct policy_handle _hGroup /* [in] */,
17936 : enum clusapi_GroupControlCode _dwControlCode /* [in] */,
17937 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
17938 : uint32_t _nInBufferSize /* [in] */,
17939 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
17940 : uint32_t _nOutBufferSize /* [in] */,
17941 : uint32_t *_lpBytesReturned /* [out] [ref] */,
17942 : uint32_t *_lpcbRequired /* [out] [ref] */,
17943 : WERROR *_rpc_status /* [out] [ref] */)
17944 : {
17945 : struct tevent_req *req;
17946 : struct dcerpc_clusapi_GroupControl_state *state;
17947 : struct tevent_req *subreq;
17948 :
17949 0 : req = tevent_req_create(mem_ctx, &state,
17950 : struct dcerpc_clusapi_GroupControl_state);
17951 0 : if (req == NULL) {
17952 0 : return NULL;
17953 : }
17954 0 : state->out_mem_ctx = NULL;
17955 :
17956 : /* In parameters */
17957 0 : state->orig.in.hGroup = _hGroup;
17958 0 : state->orig.in.dwControlCode = _dwControlCode;
17959 0 : state->orig.in.lpInBuffer = _lpInBuffer;
17960 0 : state->orig.in.nInBufferSize = _nInBufferSize;
17961 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
17962 :
17963 : /* Out parameters */
17964 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
17965 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
17966 0 : state->orig.out.lpcbRequired = _lpcbRequired;
17967 0 : state->orig.out.rpc_status = _rpc_status;
17968 :
17969 : /* Result */
17970 0 : NDR_ZERO_STRUCT(state->orig.out.result);
17971 :
17972 0 : state->out_mem_ctx = talloc_named_const(state, 0,
17973 : "dcerpc_clusapi_GroupControl_out_memory");
17974 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
17975 0 : return tevent_req_post(req, ev);
17976 : }
17977 :
17978 : /* make a temporary copy, that we pass to the dispatch function */
17979 0 : state->tmp = state->orig;
17980 :
17981 0 : subreq = dcerpc_clusapi_GroupControl_r_send(state, ev, h, &state->tmp);
17982 0 : if (tevent_req_nomem(subreq, req)) {
17983 0 : return tevent_req_post(req, ev);
17984 : }
17985 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GroupControl_done, req);
17986 0 : return req;
17987 : }
17988 :
17989 0 : static void dcerpc_clusapi_GroupControl_done(struct tevent_req *subreq)
17990 : {
17991 0 : struct tevent_req *req = tevent_req_callback_data(
17992 : subreq, struct tevent_req);
17993 0 : struct dcerpc_clusapi_GroupControl_state *state = tevent_req_data(
17994 : req, struct dcerpc_clusapi_GroupControl_state);
17995 : NTSTATUS status;
17996 : TALLOC_CTX *mem_ctx;
17997 :
17998 0 : if (state->out_mem_ctx) {
17999 0 : mem_ctx = state->out_mem_ctx;
18000 : } else {
18001 0 : mem_ctx = state;
18002 : }
18003 :
18004 0 : status = dcerpc_clusapi_GroupControl_r_recv(subreq, mem_ctx);
18005 0 : TALLOC_FREE(subreq);
18006 0 : if (tevent_req_nterror(req, status)) {
18007 0 : return;
18008 : }
18009 :
18010 : /* Copy out parameters */
18011 : {
18012 : size_t _copy_len_lpOutBuffer;
18013 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
18014 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
18015 0 : return;
18016 : }
18017 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
18018 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
18019 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
18020 : }
18021 : }
18022 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
18023 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
18024 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
18025 :
18026 : /* Copy result */
18027 0 : state->orig.out.result = state->tmp.out.result;
18028 :
18029 : /* Reset temporary structure */
18030 0 : NDR_ZERO_STRUCT(state->tmp);
18031 :
18032 0 : tevent_req_done(req);
18033 : }
18034 :
18035 0 : NTSTATUS dcerpc_clusapi_GroupControl_recv(struct tevent_req *req,
18036 : TALLOC_CTX *mem_ctx,
18037 : WERROR *result)
18038 : {
18039 0 : struct dcerpc_clusapi_GroupControl_state *state = tevent_req_data(
18040 : req, struct dcerpc_clusapi_GroupControl_state);
18041 : NTSTATUS status;
18042 :
18043 0 : if (tevent_req_is_nterror(req, &status)) {
18044 0 : tevent_req_received(req);
18045 0 : return status;
18046 : }
18047 :
18048 : /* Steal possible out parameters to the callers context */
18049 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18050 :
18051 : /* Return result */
18052 0 : *result = state->orig.out.result;
18053 :
18054 0 : tevent_req_received(req);
18055 0 : return NT_STATUS_OK;
18056 : }
18057 :
18058 0 : NTSTATUS dcerpc_clusapi_GroupControl(struct dcerpc_binding_handle *h,
18059 : TALLOC_CTX *mem_ctx,
18060 : struct policy_handle _hGroup /* [in] */,
18061 : enum clusapi_GroupControlCode _dwControlCode /* [in] */,
18062 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
18063 : uint32_t _nInBufferSize /* [in] */,
18064 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
18065 : uint32_t _nOutBufferSize /* [in] */,
18066 : uint32_t *_lpBytesReturned /* [out] [ref] */,
18067 : uint32_t *_lpcbRequired /* [out] [ref] */,
18068 : WERROR *_rpc_status /* [out] [ref] */,
18069 : WERROR *result)
18070 : {
18071 : struct clusapi_GroupControl r;
18072 : NTSTATUS status;
18073 :
18074 : /* In parameters */
18075 0 : r.in.hGroup = _hGroup;
18076 0 : r.in.dwControlCode = _dwControlCode;
18077 0 : r.in.lpInBuffer = _lpInBuffer;
18078 0 : r.in.nInBufferSize = _nInBufferSize;
18079 0 : r.in.nOutBufferSize = _nOutBufferSize;
18080 :
18081 : /* Out parameters */
18082 0 : r.out.lpOutBuffer = _lpOutBuffer;
18083 0 : r.out.lpBytesReturned = _lpBytesReturned;
18084 0 : r.out.lpcbRequired = _lpcbRequired;
18085 0 : r.out.rpc_status = _rpc_status;
18086 :
18087 : /* Result */
18088 0 : NDR_ZERO_STRUCT(r.out.result);
18089 :
18090 0 : status = dcerpc_clusapi_GroupControl_r(h, mem_ctx, &r);
18091 0 : if (!NT_STATUS_IS_OK(status)) {
18092 0 : return status;
18093 : }
18094 :
18095 : /* Return variables */
18096 : {
18097 : size_t _copy_len_lpOutBuffer;
18098 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
18099 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
18100 : }
18101 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
18102 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
18103 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
18104 : }
18105 : }
18106 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
18107 0 : *_lpcbRequired = *r.out.lpcbRequired;
18108 0 : *_rpc_status = *r.out.rpc_status;
18109 :
18110 : /* Return result */
18111 0 : *result = r.out.result;
18112 :
18113 0 : return NT_STATUS_OK;
18114 : }
18115 :
18116 : struct dcerpc_clusapi_NodeNodeControl_r_state {
18117 : TALLOC_CTX *out_mem_ctx;
18118 : };
18119 :
18120 : static void dcerpc_clusapi_NodeNodeControl_r_done(struct tevent_req *subreq);
18121 :
18122 0 : struct tevent_req *dcerpc_clusapi_NodeNodeControl_r_send(TALLOC_CTX *mem_ctx,
18123 : struct tevent_context *ev,
18124 : struct dcerpc_binding_handle *h,
18125 : struct clusapi_NodeNodeControl *r)
18126 : {
18127 : struct tevent_req *req;
18128 : struct dcerpc_clusapi_NodeNodeControl_r_state *state;
18129 : struct tevent_req *subreq;
18130 :
18131 0 : req = tevent_req_create(mem_ctx, &state,
18132 : struct dcerpc_clusapi_NodeNodeControl_r_state);
18133 0 : if (req == NULL) {
18134 0 : return NULL;
18135 : }
18136 :
18137 0 : state->out_mem_ctx = talloc_new(state);
18138 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18139 0 : return tevent_req_post(req, ev);
18140 : }
18141 :
18142 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
18143 : NULL, &ndr_table_clusapi,
18144 0 : NDR_CLUSAPI_NODENODECONTROL, state->out_mem_ctx, r);
18145 0 : if (tevent_req_nomem(subreq, req)) {
18146 0 : return tevent_req_post(req, ev);
18147 : }
18148 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNodeControl_r_done, req);
18149 :
18150 0 : return req;
18151 : }
18152 :
18153 0 : static void dcerpc_clusapi_NodeNodeControl_r_done(struct tevent_req *subreq)
18154 : {
18155 0 : struct tevent_req *req =
18156 0 : tevent_req_callback_data(subreq,
18157 : struct tevent_req);
18158 : NTSTATUS status;
18159 :
18160 0 : status = dcerpc_binding_handle_call_recv(subreq);
18161 0 : TALLOC_FREE(subreq);
18162 0 : if (tevent_req_nterror(req, status)) {
18163 0 : return;
18164 : }
18165 :
18166 0 : tevent_req_done(req);
18167 : }
18168 :
18169 0 : NTSTATUS dcerpc_clusapi_NodeNodeControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
18170 : {
18171 0 : struct dcerpc_clusapi_NodeNodeControl_r_state *state =
18172 0 : tevent_req_data(req,
18173 : struct dcerpc_clusapi_NodeNodeControl_r_state);
18174 : NTSTATUS status;
18175 :
18176 0 : if (tevent_req_is_nterror(req, &status)) {
18177 0 : tevent_req_received(req);
18178 0 : return status;
18179 : }
18180 :
18181 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18182 :
18183 0 : tevent_req_received(req);
18184 0 : return NT_STATUS_OK;
18185 : }
18186 :
18187 0 : NTSTATUS dcerpc_clusapi_NodeNodeControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeNodeControl *r)
18188 : {
18189 : NTSTATUS status;
18190 :
18191 0 : status = dcerpc_binding_handle_call(h,
18192 : NULL, &ndr_table_clusapi,
18193 : NDR_CLUSAPI_NODENODECONTROL, mem_ctx, r);
18194 :
18195 0 : return status;
18196 : }
18197 :
18198 : struct dcerpc_clusapi_NodeNodeControl_state {
18199 : struct clusapi_NodeNodeControl orig;
18200 : struct clusapi_NodeNodeControl tmp;
18201 : TALLOC_CTX *out_mem_ctx;
18202 : };
18203 :
18204 : static void dcerpc_clusapi_NodeNodeControl_done(struct tevent_req *subreq);
18205 :
18206 0 : struct tevent_req *dcerpc_clusapi_NodeNodeControl_send(TALLOC_CTX *mem_ctx,
18207 : struct tevent_context *ev,
18208 : struct dcerpc_binding_handle *h,
18209 : struct policy_handle _hNode /* [in] */,
18210 : struct policy_handle _hHostNode /* [in] */,
18211 : uint32_t _dwControlCode /* [in] */,
18212 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
18213 : uint32_t _nInBufferSize /* [in] */,
18214 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
18215 : uint32_t _nOutBufferSize /* [in] */,
18216 : uint32_t *_lpBytesReturned /* [out] [ref] */,
18217 : uint32_t *_lpcbRequired /* [out] [ref] */,
18218 : WERROR *_rpc_status /* [out] [ref] */)
18219 : {
18220 : struct tevent_req *req;
18221 : struct dcerpc_clusapi_NodeNodeControl_state *state;
18222 : struct tevent_req *subreq;
18223 :
18224 0 : req = tevent_req_create(mem_ctx, &state,
18225 : struct dcerpc_clusapi_NodeNodeControl_state);
18226 0 : if (req == NULL) {
18227 0 : return NULL;
18228 : }
18229 0 : state->out_mem_ctx = NULL;
18230 :
18231 : /* In parameters */
18232 0 : state->orig.in.hNode = _hNode;
18233 0 : state->orig.in.hHostNode = _hHostNode;
18234 0 : state->orig.in.dwControlCode = _dwControlCode;
18235 0 : state->orig.in.lpInBuffer = _lpInBuffer;
18236 0 : state->orig.in.nInBufferSize = _nInBufferSize;
18237 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
18238 :
18239 : /* Out parameters */
18240 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
18241 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
18242 0 : state->orig.out.lpcbRequired = _lpcbRequired;
18243 0 : state->orig.out.rpc_status = _rpc_status;
18244 :
18245 : /* Result */
18246 0 : NDR_ZERO_STRUCT(state->orig.out.result);
18247 :
18248 0 : state->out_mem_ctx = talloc_named_const(state, 0,
18249 : "dcerpc_clusapi_NodeNodeControl_out_memory");
18250 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18251 0 : return tevent_req_post(req, ev);
18252 : }
18253 :
18254 : /* make a temporary copy, that we pass to the dispatch function */
18255 0 : state->tmp = state->orig;
18256 :
18257 0 : subreq = dcerpc_clusapi_NodeNodeControl_r_send(state, ev, h, &state->tmp);
18258 0 : if (tevent_req_nomem(subreq, req)) {
18259 0 : return tevent_req_post(req, ev);
18260 : }
18261 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNodeControl_done, req);
18262 0 : return req;
18263 : }
18264 :
18265 0 : static void dcerpc_clusapi_NodeNodeControl_done(struct tevent_req *subreq)
18266 : {
18267 0 : struct tevent_req *req = tevent_req_callback_data(
18268 : subreq, struct tevent_req);
18269 0 : struct dcerpc_clusapi_NodeNodeControl_state *state = tevent_req_data(
18270 : req, struct dcerpc_clusapi_NodeNodeControl_state);
18271 : NTSTATUS status;
18272 : TALLOC_CTX *mem_ctx;
18273 :
18274 0 : if (state->out_mem_ctx) {
18275 0 : mem_ctx = state->out_mem_ctx;
18276 : } else {
18277 0 : mem_ctx = state;
18278 : }
18279 :
18280 0 : status = dcerpc_clusapi_NodeNodeControl_r_recv(subreq, mem_ctx);
18281 0 : TALLOC_FREE(subreq);
18282 0 : if (tevent_req_nterror(req, status)) {
18283 0 : return;
18284 : }
18285 :
18286 : /* Copy out parameters */
18287 : {
18288 : size_t _copy_len_lpOutBuffer;
18289 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
18290 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
18291 0 : return;
18292 : }
18293 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
18294 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
18295 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
18296 : }
18297 : }
18298 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
18299 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
18300 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
18301 :
18302 : /* Copy result */
18303 0 : state->orig.out.result = state->tmp.out.result;
18304 :
18305 : /* Reset temporary structure */
18306 0 : NDR_ZERO_STRUCT(state->tmp);
18307 :
18308 0 : tevent_req_done(req);
18309 : }
18310 :
18311 0 : NTSTATUS dcerpc_clusapi_NodeNodeControl_recv(struct tevent_req *req,
18312 : TALLOC_CTX *mem_ctx,
18313 : WERROR *result)
18314 : {
18315 0 : struct dcerpc_clusapi_NodeNodeControl_state *state = tevent_req_data(
18316 : req, struct dcerpc_clusapi_NodeNodeControl_state);
18317 : NTSTATUS status;
18318 :
18319 0 : if (tevent_req_is_nterror(req, &status)) {
18320 0 : tevent_req_received(req);
18321 0 : return status;
18322 : }
18323 :
18324 : /* Steal possible out parameters to the callers context */
18325 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18326 :
18327 : /* Return result */
18328 0 : *result = state->orig.out.result;
18329 :
18330 0 : tevent_req_received(req);
18331 0 : return NT_STATUS_OK;
18332 : }
18333 :
18334 0 : NTSTATUS dcerpc_clusapi_NodeNodeControl(struct dcerpc_binding_handle *h,
18335 : TALLOC_CTX *mem_ctx,
18336 : struct policy_handle _hNode /* [in] */,
18337 : struct policy_handle _hHostNode /* [in] */,
18338 : uint32_t _dwControlCode /* [in] */,
18339 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
18340 : uint32_t _nInBufferSize /* [in] */,
18341 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
18342 : uint32_t _nOutBufferSize /* [in] */,
18343 : uint32_t *_lpBytesReturned /* [out] [ref] */,
18344 : uint32_t *_lpcbRequired /* [out] [ref] */,
18345 : WERROR *_rpc_status /* [out] [ref] */,
18346 : WERROR *result)
18347 : {
18348 : struct clusapi_NodeNodeControl r;
18349 : NTSTATUS status;
18350 :
18351 : /* In parameters */
18352 0 : r.in.hNode = _hNode;
18353 0 : r.in.hHostNode = _hHostNode;
18354 0 : r.in.dwControlCode = _dwControlCode;
18355 0 : r.in.lpInBuffer = _lpInBuffer;
18356 0 : r.in.nInBufferSize = _nInBufferSize;
18357 0 : r.in.nOutBufferSize = _nOutBufferSize;
18358 :
18359 : /* Out parameters */
18360 0 : r.out.lpOutBuffer = _lpOutBuffer;
18361 0 : r.out.lpBytesReturned = _lpBytesReturned;
18362 0 : r.out.lpcbRequired = _lpcbRequired;
18363 0 : r.out.rpc_status = _rpc_status;
18364 :
18365 : /* Result */
18366 0 : NDR_ZERO_STRUCT(r.out.result);
18367 :
18368 0 : status = dcerpc_clusapi_NodeNodeControl_r(h, mem_ctx, &r);
18369 0 : if (!NT_STATUS_IS_OK(status)) {
18370 0 : return status;
18371 : }
18372 :
18373 : /* Return variables */
18374 : {
18375 : size_t _copy_len_lpOutBuffer;
18376 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
18377 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
18378 : }
18379 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
18380 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
18381 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
18382 : }
18383 : }
18384 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
18385 0 : *_lpcbRequired = *r.out.lpcbRequired;
18386 0 : *_rpc_status = *r.out.rpc_status;
18387 :
18388 : /* Return result */
18389 0 : *result = r.out.result;
18390 :
18391 0 : return NT_STATUS_OK;
18392 : }
18393 :
18394 : struct dcerpc_clusapi_NodeControl_r_state {
18395 : TALLOC_CTX *out_mem_ctx;
18396 : };
18397 :
18398 : static void dcerpc_clusapi_NodeControl_r_done(struct tevent_req *subreq);
18399 :
18400 0 : struct tevent_req *dcerpc_clusapi_NodeControl_r_send(TALLOC_CTX *mem_ctx,
18401 : struct tevent_context *ev,
18402 : struct dcerpc_binding_handle *h,
18403 : struct clusapi_NodeControl *r)
18404 : {
18405 : struct tevent_req *req;
18406 : struct dcerpc_clusapi_NodeControl_r_state *state;
18407 : struct tevent_req *subreq;
18408 :
18409 0 : req = tevent_req_create(mem_ctx, &state,
18410 : struct dcerpc_clusapi_NodeControl_r_state);
18411 0 : if (req == NULL) {
18412 0 : return NULL;
18413 : }
18414 :
18415 0 : state->out_mem_ctx = talloc_new(state);
18416 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18417 0 : return tevent_req_post(req, ev);
18418 : }
18419 :
18420 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
18421 : NULL, &ndr_table_clusapi,
18422 0 : NDR_CLUSAPI_NODECONTROL, state->out_mem_ctx, r);
18423 0 : if (tevent_req_nomem(subreq, req)) {
18424 0 : return tevent_req_post(req, ev);
18425 : }
18426 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeControl_r_done, req);
18427 :
18428 0 : return req;
18429 : }
18430 :
18431 0 : static void dcerpc_clusapi_NodeControl_r_done(struct tevent_req *subreq)
18432 : {
18433 0 : struct tevent_req *req =
18434 0 : tevent_req_callback_data(subreq,
18435 : struct tevent_req);
18436 : NTSTATUS status;
18437 :
18438 0 : status = dcerpc_binding_handle_call_recv(subreq);
18439 0 : TALLOC_FREE(subreq);
18440 0 : if (tevent_req_nterror(req, status)) {
18441 0 : return;
18442 : }
18443 :
18444 0 : tevent_req_done(req);
18445 : }
18446 :
18447 0 : NTSTATUS dcerpc_clusapi_NodeControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
18448 : {
18449 0 : struct dcerpc_clusapi_NodeControl_r_state *state =
18450 0 : tevent_req_data(req,
18451 : struct dcerpc_clusapi_NodeControl_r_state);
18452 : NTSTATUS status;
18453 :
18454 0 : if (tevent_req_is_nterror(req, &status)) {
18455 0 : tevent_req_received(req);
18456 0 : return status;
18457 : }
18458 :
18459 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18460 :
18461 0 : tevent_req_received(req);
18462 0 : return NT_STATUS_OK;
18463 : }
18464 :
18465 0 : NTSTATUS dcerpc_clusapi_NodeControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeControl *r)
18466 : {
18467 : NTSTATUS status;
18468 :
18469 0 : status = dcerpc_binding_handle_call(h,
18470 : NULL, &ndr_table_clusapi,
18471 : NDR_CLUSAPI_NODECONTROL, mem_ctx, r);
18472 :
18473 0 : return status;
18474 : }
18475 :
18476 : struct dcerpc_clusapi_NodeControl_state {
18477 : struct clusapi_NodeControl orig;
18478 : struct clusapi_NodeControl tmp;
18479 : TALLOC_CTX *out_mem_ctx;
18480 : };
18481 :
18482 : static void dcerpc_clusapi_NodeControl_done(struct tevent_req *subreq);
18483 :
18484 0 : struct tevent_req *dcerpc_clusapi_NodeControl_send(TALLOC_CTX *mem_ctx,
18485 : struct tevent_context *ev,
18486 : struct dcerpc_binding_handle *h,
18487 : struct policy_handle _hNode /* [in] */,
18488 : enum clusapi_NodeControlCode _dwControlCode /* [in] */,
18489 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
18490 : uint32_t _nInBufferSize /* [in] */,
18491 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
18492 : uint32_t _nOutBufferSize /* [in] */,
18493 : uint32_t *_lpBytesReturned /* [out] [ref] */,
18494 : uint32_t *_lpcbRequired /* [out] [ref] */,
18495 : WERROR *_rpc_status /* [out] [ref] */)
18496 : {
18497 : struct tevent_req *req;
18498 : struct dcerpc_clusapi_NodeControl_state *state;
18499 : struct tevent_req *subreq;
18500 :
18501 0 : req = tevent_req_create(mem_ctx, &state,
18502 : struct dcerpc_clusapi_NodeControl_state);
18503 0 : if (req == NULL) {
18504 0 : return NULL;
18505 : }
18506 0 : state->out_mem_ctx = NULL;
18507 :
18508 : /* In parameters */
18509 0 : state->orig.in.hNode = _hNode;
18510 0 : state->orig.in.dwControlCode = _dwControlCode;
18511 0 : state->orig.in.lpInBuffer = _lpInBuffer;
18512 0 : state->orig.in.nInBufferSize = _nInBufferSize;
18513 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
18514 :
18515 : /* Out parameters */
18516 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
18517 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
18518 0 : state->orig.out.lpcbRequired = _lpcbRequired;
18519 0 : state->orig.out.rpc_status = _rpc_status;
18520 :
18521 : /* Result */
18522 0 : NDR_ZERO_STRUCT(state->orig.out.result);
18523 :
18524 0 : state->out_mem_ctx = talloc_named_const(state, 0,
18525 : "dcerpc_clusapi_NodeControl_out_memory");
18526 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18527 0 : return tevent_req_post(req, ev);
18528 : }
18529 :
18530 : /* make a temporary copy, that we pass to the dispatch function */
18531 0 : state->tmp = state->orig;
18532 :
18533 0 : subreq = dcerpc_clusapi_NodeControl_r_send(state, ev, h, &state->tmp);
18534 0 : if (tevent_req_nomem(subreq, req)) {
18535 0 : return tevent_req_post(req, ev);
18536 : }
18537 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeControl_done, req);
18538 0 : return req;
18539 : }
18540 :
18541 0 : static void dcerpc_clusapi_NodeControl_done(struct tevent_req *subreq)
18542 : {
18543 0 : struct tevent_req *req = tevent_req_callback_data(
18544 : subreq, struct tevent_req);
18545 0 : struct dcerpc_clusapi_NodeControl_state *state = tevent_req_data(
18546 : req, struct dcerpc_clusapi_NodeControl_state);
18547 : NTSTATUS status;
18548 : TALLOC_CTX *mem_ctx;
18549 :
18550 0 : if (state->out_mem_ctx) {
18551 0 : mem_ctx = state->out_mem_ctx;
18552 : } else {
18553 0 : mem_ctx = state;
18554 : }
18555 :
18556 0 : status = dcerpc_clusapi_NodeControl_r_recv(subreq, mem_ctx);
18557 0 : TALLOC_FREE(subreq);
18558 0 : if (tevent_req_nterror(req, status)) {
18559 0 : return;
18560 : }
18561 :
18562 : /* Copy out parameters */
18563 : {
18564 : size_t _copy_len_lpOutBuffer;
18565 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
18566 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
18567 0 : return;
18568 : }
18569 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
18570 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
18571 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
18572 : }
18573 : }
18574 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
18575 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
18576 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
18577 :
18578 : /* Copy result */
18579 0 : state->orig.out.result = state->tmp.out.result;
18580 :
18581 : /* Reset temporary structure */
18582 0 : NDR_ZERO_STRUCT(state->tmp);
18583 :
18584 0 : tevent_req_done(req);
18585 : }
18586 :
18587 0 : NTSTATUS dcerpc_clusapi_NodeControl_recv(struct tevent_req *req,
18588 : TALLOC_CTX *mem_ctx,
18589 : WERROR *result)
18590 : {
18591 0 : struct dcerpc_clusapi_NodeControl_state *state = tevent_req_data(
18592 : req, struct dcerpc_clusapi_NodeControl_state);
18593 : NTSTATUS status;
18594 :
18595 0 : if (tevent_req_is_nterror(req, &status)) {
18596 0 : tevent_req_received(req);
18597 0 : return status;
18598 : }
18599 :
18600 : /* Steal possible out parameters to the callers context */
18601 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18602 :
18603 : /* Return result */
18604 0 : *result = state->orig.out.result;
18605 :
18606 0 : tevent_req_received(req);
18607 0 : return NT_STATUS_OK;
18608 : }
18609 :
18610 0 : NTSTATUS dcerpc_clusapi_NodeControl(struct dcerpc_binding_handle *h,
18611 : TALLOC_CTX *mem_ctx,
18612 : struct policy_handle _hNode /* [in] */,
18613 : enum clusapi_NodeControlCode _dwControlCode /* [in] */,
18614 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
18615 : uint32_t _nInBufferSize /* [in] */,
18616 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
18617 : uint32_t _nOutBufferSize /* [in] */,
18618 : uint32_t *_lpBytesReturned /* [out] [ref] */,
18619 : uint32_t *_lpcbRequired /* [out] [ref] */,
18620 : WERROR *_rpc_status /* [out] [ref] */,
18621 : WERROR *result)
18622 : {
18623 : struct clusapi_NodeControl r;
18624 : NTSTATUS status;
18625 :
18626 : /* In parameters */
18627 0 : r.in.hNode = _hNode;
18628 0 : r.in.dwControlCode = _dwControlCode;
18629 0 : r.in.lpInBuffer = _lpInBuffer;
18630 0 : r.in.nInBufferSize = _nInBufferSize;
18631 0 : r.in.nOutBufferSize = _nOutBufferSize;
18632 :
18633 : /* Out parameters */
18634 0 : r.out.lpOutBuffer = _lpOutBuffer;
18635 0 : r.out.lpBytesReturned = _lpBytesReturned;
18636 0 : r.out.lpcbRequired = _lpcbRequired;
18637 0 : r.out.rpc_status = _rpc_status;
18638 :
18639 : /* Result */
18640 0 : NDR_ZERO_STRUCT(r.out.result);
18641 :
18642 0 : status = dcerpc_clusapi_NodeControl_r(h, mem_ctx, &r);
18643 0 : if (!NT_STATUS_IS_OK(status)) {
18644 0 : return status;
18645 : }
18646 :
18647 : /* Return variables */
18648 : {
18649 : size_t _copy_len_lpOutBuffer;
18650 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
18651 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
18652 : }
18653 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
18654 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
18655 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
18656 : }
18657 : }
18658 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
18659 0 : *_lpcbRequired = *r.out.lpcbRequired;
18660 0 : *_rpc_status = *r.out.rpc_status;
18661 :
18662 : /* Return result */
18663 0 : *result = r.out.result;
18664 :
18665 0 : return NT_STATUS_OK;
18666 : }
18667 :
18668 : struct dcerpc_Opnum80NotUsedOnWire_r_state {
18669 : TALLOC_CTX *out_mem_ctx;
18670 : };
18671 :
18672 : static void dcerpc_Opnum80NotUsedOnWire_r_done(struct tevent_req *subreq);
18673 :
18674 0 : struct tevent_req *dcerpc_Opnum80NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
18675 : struct tevent_context *ev,
18676 : struct dcerpc_binding_handle *h,
18677 : struct Opnum80NotUsedOnWire *r)
18678 : {
18679 : struct tevent_req *req;
18680 : struct dcerpc_Opnum80NotUsedOnWire_r_state *state;
18681 : struct tevent_req *subreq;
18682 :
18683 0 : req = tevent_req_create(mem_ctx, &state,
18684 : struct dcerpc_Opnum80NotUsedOnWire_r_state);
18685 0 : if (req == NULL) {
18686 0 : return NULL;
18687 : }
18688 :
18689 0 : state->out_mem_ctx = NULL;
18690 :
18691 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
18692 : NULL, &ndr_table_clusapi,
18693 : NDR_OPNUM80NOTUSEDONWIRE, state, r);
18694 0 : if (tevent_req_nomem(subreq, req)) {
18695 0 : return tevent_req_post(req, ev);
18696 : }
18697 0 : tevent_req_set_callback(subreq, dcerpc_Opnum80NotUsedOnWire_r_done, req);
18698 :
18699 0 : return req;
18700 : }
18701 :
18702 0 : static void dcerpc_Opnum80NotUsedOnWire_r_done(struct tevent_req *subreq)
18703 : {
18704 0 : struct tevent_req *req =
18705 0 : tevent_req_callback_data(subreq,
18706 : struct tevent_req);
18707 : NTSTATUS status;
18708 :
18709 0 : status = dcerpc_binding_handle_call_recv(subreq);
18710 0 : TALLOC_FREE(subreq);
18711 0 : if (tevent_req_nterror(req, status)) {
18712 0 : return;
18713 : }
18714 :
18715 0 : tevent_req_done(req);
18716 : }
18717 :
18718 0 : NTSTATUS dcerpc_Opnum80NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
18719 : {
18720 0 : struct dcerpc_Opnum80NotUsedOnWire_r_state *state =
18721 0 : tevent_req_data(req,
18722 : struct dcerpc_Opnum80NotUsedOnWire_r_state);
18723 : NTSTATUS status;
18724 :
18725 0 : if (tevent_req_is_nterror(req, &status)) {
18726 0 : tevent_req_received(req);
18727 0 : return status;
18728 : }
18729 :
18730 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18731 :
18732 0 : tevent_req_received(req);
18733 0 : return NT_STATUS_OK;
18734 : }
18735 :
18736 0 : NTSTATUS dcerpc_Opnum80NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum80NotUsedOnWire *r)
18737 : {
18738 : NTSTATUS status;
18739 :
18740 0 : status = dcerpc_binding_handle_call(h,
18741 : NULL, &ndr_table_clusapi,
18742 : NDR_OPNUM80NOTUSEDONWIRE, mem_ctx, r);
18743 :
18744 0 : return status;
18745 : }
18746 :
18747 : struct dcerpc_Opnum80NotUsedOnWire_state {
18748 : struct Opnum80NotUsedOnWire orig;
18749 : struct Opnum80NotUsedOnWire tmp;
18750 : TALLOC_CTX *out_mem_ctx;
18751 : };
18752 :
18753 : static void dcerpc_Opnum80NotUsedOnWire_done(struct tevent_req *subreq);
18754 :
18755 0 : struct tevent_req *dcerpc_Opnum80NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
18756 : struct tevent_context *ev,
18757 : struct dcerpc_binding_handle *h)
18758 : {
18759 : struct tevent_req *req;
18760 : struct dcerpc_Opnum80NotUsedOnWire_state *state;
18761 : struct tevent_req *subreq;
18762 :
18763 0 : req = tevent_req_create(mem_ctx, &state,
18764 : struct dcerpc_Opnum80NotUsedOnWire_state);
18765 0 : if (req == NULL) {
18766 0 : return NULL;
18767 : }
18768 0 : state->out_mem_ctx = NULL;
18769 :
18770 : /* In parameters */
18771 :
18772 : /* Out parameters */
18773 :
18774 : /* Result */
18775 0 : NDR_ZERO_STRUCT(state->orig.out.result);
18776 :
18777 : /* make a temporary copy, that we pass to the dispatch function */
18778 0 : state->tmp = state->orig;
18779 :
18780 0 : subreq = dcerpc_Opnum80NotUsedOnWire_r_send(state, ev, h, &state->tmp);
18781 0 : if (tevent_req_nomem(subreq, req)) {
18782 0 : return tevent_req_post(req, ev);
18783 : }
18784 0 : tevent_req_set_callback(subreq, dcerpc_Opnum80NotUsedOnWire_done, req);
18785 0 : return req;
18786 : }
18787 :
18788 0 : static void dcerpc_Opnum80NotUsedOnWire_done(struct tevent_req *subreq)
18789 : {
18790 0 : struct tevent_req *req = tevent_req_callback_data(
18791 : subreq, struct tevent_req);
18792 0 : struct dcerpc_Opnum80NotUsedOnWire_state *state = tevent_req_data(
18793 : req, struct dcerpc_Opnum80NotUsedOnWire_state);
18794 : NTSTATUS status;
18795 : TALLOC_CTX *mem_ctx;
18796 :
18797 0 : if (state->out_mem_ctx) {
18798 0 : mem_ctx = state->out_mem_ctx;
18799 : } else {
18800 0 : mem_ctx = state;
18801 : }
18802 :
18803 0 : status = dcerpc_Opnum80NotUsedOnWire_r_recv(subreq, mem_ctx);
18804 0 : TALLOC_FREE(subreq);
18805 0 : if (tevent_req_nterror(req, status)) {
18806 0 : return;
18807 : }
18808 :
18809 : /* Copy out parameters */
18810 :
18811 : /* Copy result */
18812 0 : state->orig.out.result = state->tmp.out.result;
18813 :
18814 : /* Reset temporary structure */
18815 0 : NDR_ZERO_STRUCT(state->tmp);
18816 :
18817 0 : tevent_req_done(req);
18818 : }
18819 :
18820 0 : NTSTATUS dcerpc_Opnum80NotUsedOnWire_recv(struct tevent_req *req,
18821 : TALLOC_CTX *mem_ctx,
18822 : WERROR *result)
18823 : {
18824 0 : struct dcerpc_Opnum80NotUsedOnWire_state *state = tevent_req_data(
18825 : req, struct dcerpc_Opnum80NotUsedOnWire_state);
18826 : NTSTATUS status;
18827 :
18828 0 : if (tevent_req_is_nterror(req, &status)) {
18829 0 : tevent_req_received(req);
18830 0 : return status;
18831 : }
18832 :
18833 : /* Steal possible out parameters to the callers context */
18834 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18835 :
18836 : /* Return result */
18837 0 : *result = state->orig.out.result;
18838 :
18839 0 : tevent_req_received(req);
18840 0 : return NT_STATUS_OK;
18841 : }
18842 :
18843 0 : NTSTATUS dcerpc_Opnum80NotUsedOnWire(struct dcerpc_binding_handle *h,
18844 : TALLOC_CTX *mem_ctx,
18845 : WERROR *result)
18846 : {
18847 : struct Opnum80NotUsedOnWire r;
18848 : NTSTATUS status;
18849 :
18850 : /* In parameters */
18851 :
18852 : /* Out parameters */
18853 :
18854 : /* Result */
18855 0 : NDR_ZERO_STRUCT(r.out.result);
18856 :
18857 0 : status = dcerpc_Opnum80NotUsedOnWire_r(h, mem_ctx, &r);
18858 0 : if (!NT_STATUS_IS_OK(status)) {
18859 0 : return status;
18860 : }
18861 :
18862 : /* Return variables */
18863 :
18864 : /* Return result */
18865 0 : *result = r.out.result;
18866 :
18867 0 : return NT_STATUS_OK;
18868 : }
18869 :
18870 : struct dcerpc_clusapi_OpenNetwork_r_state {
18871 : TALLOC_CTX *out_mem_ctx;
18872 : };
18873 :
18874 : static void dcerpc_clusapi_OpenNetwork_r_done(struct tevent_req *subreq);
18875 :
18876 0 : struct tevent_req *dcerpc_clusapi_OpenNetwork_r_send(TALLOC_CTX *mem_ctx,
18877 : struct tevent_context *ev,
18878 : struct dcerpc_binding_handle *h,
18879 : struct clusapi_OpenNetwork *r)
18880 : {
18881 : struct tevent_req *req;
18882 : struct dcerpc_clusapi_OpenNetwork_r_state *state;
18883 : struct tevent_req *subreq;
18884 :
18885 0 : req = tevent_req_create(mem_ctx, &state,
18886 : struct dcerpc_clusapi_OpenNetwork_r_state);
18887 0 : if (req == NULL) {
18888 0 : return NULL;
18889 : }
18890 :
18891 0 : state->out_mem_ctx = talloc_new(state);
18892 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18893 0 : return tevent_req_post(req, ev);
18894 : }
18895 :
18896 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
18897 : NULL, &ndr_table_clusapi,
18898 0 : NDR_CLUSAPI_OPENNETWORK, state->out_mem_ctx, r);
18899 0 : if (tevent_req_nomem(subreq, req)) {
18900 0 : return tevent_req_post(req, ev);
18901 : }
18902 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetwork_r_done, req);
18903 :
18904 0 : return req;
18905 : }
18906 :
18907 0 : static void dcerpc_clusapi_OpenNetwork_r_done(struct tevent_req *subreq)
18908 : {
18909 0 : struct tevent_req *req =
18910 0 : tevent_req_callback_data(subreq,
18911 : struct tevent_req);
18912 : NTSTATUS status;
18913 :
18914 0 : status = dcerpc_binding_handle_call_recv(subreq);
18915 0 : TALLOC_FREE(subreq);
18916 0 : if (tevent_req_nterror(req, status)) {
18917 0 : return;
18918 : }
18919 :
18920 0 : tevent_req_done(req);
18921 : }
18922 :
18923 0 : NTSTATUS dcerpc_clusapi_OpenNetwork_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
18924 : {
18925 0 : struct dcerpc_clusapi_OpenNetwork_r_state *state =
18926 0 : tevent_req_data(req,
18927 : struct dcerpc_clusapi_OpenNetwork_r_state);
18928 : NTSTATUS status;
18929 :
18930 0 : if (tevent_req_is_nterror(req, &status)) {
18931 0 : tevent_req_received(req);
18932 0 : return status;
18933 : }
18934 :
18935 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
18936 :
18937 0 : tevent_req_received(req);
18938 0 : return NT_STATUS_OK;
18939 : }
18940 :
18941 0 : NTSTATUS dcerpc_clusapi_OpenNetwork_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNetwork *r)
18942 : {
18943 : NTSTATUS status;
18944 :
18945 0 : status = dcerpc_binding_handle_call(h,
18946 : NULL, &ndr_table_clusapi,
18947 : NDR_CLUSAPI_OPENNETWORK, mem_ctx, r);
18948 :
18949 0 : return status;
18950 : }
18951 :
18952 : struct dcerpc_clusapi_OpenNetwork_state {
18953 : struct clusapi_OpenNetwork orig;
18954 : struct clusapi_OpenNetwork tmp;
18955 : TALLOC_CTX *out_mem_ctx;
18956 : };
18957 :
18958 : static void dcerpc_clusapi_OpenNetwork_done(struct tevent_req *subreq);
18959 :
18960 0 : struct tevent_req *dcerpc_clusapi_OpenNetwork_send(TALLOC_CTX *mem_ctx,
18961 : struct tevent_context *ev,
18962 : struct dcerpc_binding_handle *h,
18963 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
18964 : WERROR *_Status /* [out] [ref] */,
18965 : WERROR *_rpc_status /* [out] [ref] */,
18966 : struct policy_handle *_hNetwork /* [out] [ref] */)
18967 : {
18968 : struct tevent_req *req;
18969 : struct dcerpc_clusapi_OpenNetwork_state *state;
18970 : struct tevent_req *subreq;
18971 :
18972 0 : req = tevent_req_create(mem_ctx, &state,
18973 : struct dcerpc_clusapi_OpenNetwork_state);
18974 0 : if (req == NULL) {
18975 0 : return NULL;
18976 : }
18977 0 : state->out_mem_ctx = NULL;
18978 :
18979 : /* In parameters */
18980 0 : state->orig.in.lpszNetworkName = _lpszNetworkName;
18981 :
18982 : /* Out parameters */
18983 0 : state->orig.out.Status = _Status;
18984 0 : state->orig.out.rpc_status = _rpc_status;
18985 0 : state->orig.out.hNetwork = _hNetwork;
18986 :
18987 0 : state->out_mem_ctx = talloc_named_const(state, 0,
18988 : "dcerpc_clusapi_OpenNetwork_out_memory");
18989 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
18990 0 : return tevent_req_post(req, ev);
18991 : }
18992 :
18993 : /* make a temporary copy, that we pass to the dispatch function */
18994 0 : state->tmp = state->orig;
18995 :
18996 0 : subreq = dcerpc_clusapi_OpenNetwork_r_send(state, ev, h, &state->tmp);
18997 0 : if (tevent_req_nomem(subreq, req)) {
18998 0 : return tevent_req_post(req, ev);
18999 : }
19000 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetwork_done, req);
19001 0 : return req;
19002 : }
19003 :
19004 0 : static void dcerpc_clusapi_OpenNetwork_done(struct tevent_req *subreq)
19005 : {
19006 0 : struct tevent_req *req = tevent_req_callback_data(
19007 : subreq, struct tevent_req);
19008 0 : struct dcerpc_clusapi_OpenNetwork_state *state = tevent_req_data(
19009 : req, struct dcerpc_clusapi_OpenNetwork_state);
19010 : NTSTATUS status;
19011 : TALLOC_CTX *mem_ctx;
19012 :
19013 0 : if (state->out_mem_ctx) {
19014 0 : mem_ctx = state->out_mem_ctx;
19015 : } else {
19016 0 : mem_ctx = state;
19017 : }
19018 :
19019 0 : status = dcerpc_clusapi_OpenNetwork_r_recv(subreq, mem_ctx);
19020 0 : TALLOC_FREE(subreq);
19021 0 : if (tevent_req_nterror(req, status)) {
19022 0 : return;
19023 : }
19024 :
19025 : /* Copy out parameters */
19026 0 : *state->orig.out.Status = *state->tmp.out.Status;
19027 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
19028 0 : *state->orig.out.hNetwork = *state->tmp.out.hNetwork;
19029 :
19030 : /* Reset temporary structure */
19031 0 : NDR_ZERO_STRUCT(state->tmp);
19032 :
19033 0 : tevent_req_done(req);
19034 : }
19035 :
19036 0 : NTSTATUS dcerpc_clusapi_OpenNetwork_recv(struct tevent_req *req,
19037 : TALLOC_CTX *mem_ctx)
19038 : {
19039 0 : struct dcerpc_clusapi_OpenNetwork_state *state = tevent_req_data(
19040 : req, struct dcerpc_clusapi_OpenNetwork_state);
19041 : NTSTATUS status;
19042 :
19043 0 : if (tevent_req_is_nterror(req, &status)) {
19044 0 : tevent_req_received(req);
19045 0 : return status;
19046 : }
19047 :
19048 : /* Steal possible out parameters to the callers context */
19049 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19050 :
19051 0 : tevent_req_received(req);
19052 0 : return NT_STATUS_OK;
19053 : }
19054 :
19055 0 : NTSTATUS dcerpc_clusapi_OpenNetwork(struct dcerpc_binding_handle *h,
19056 : TALLOC_CTX *mem_ctx,
19057 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
19058 : WERROR *_Status /* [out] [ref] */,
19059 : WERROR *_rpc_status /* [out] [ref] */,
19060 : struct policy_handle *_hNetwork /* [out] [ref] */)
19061 : {
19062 : struct clusapi_OpenNetwork r;
19063 : NTSTATUS status;
19064 :
19065 : /* In parameters */
19066 0 : r.in.lpszNetworkName = _lpszNetworkName;
19067 :
19068 : /* Out parameters */
19069 0 : r.out.Status = _Status;
19070 0 : r.out.rpc_status = _rpc_status;
19071 0 : r.out.hNetwork = _hNetwork;
19072 :
19073 0 : status = dcerpc_clusapi_OpenNetwork_r(h, mem_ctx, &r);
19074 0 : if (!NT_STATUS_IS_OK(status)) {
19075 0 : return status;
19076 : }
19077 :
19078 : /* Return variables */
19079 0 : *_Status = *r.out.Status;
19080 0 : *_rpc_status = *r.out.rpc_status;
19081 0 : *_hNetwork = *r.out.hNetwork;
19082 :
19083 : /* Return result */
19084 :
19085 0 : return NT_STATUS_OK;
19086 : }
19087 :
19088 : struct dcerpc_clusapi_CloseNetwork_r_state {
19089 : TALLOC_CTX *out_mem_ctx;
19090 : };
19091 :
19092 : static void dcerpc_clusapi_CloseNetwork_r_done(struct tevent_req *subreq);
19093 :
19094 0 : struct tevent_req *dcerpc_clusapi_CloseNetwork_r_send(TALLOC_CTX *mem_ctx,
19095 : struct tevent_context *ev,
19096 : struct dcerpc_binding_handle *h,
19097 : struct clusapi_CloseNetwork *r)
19098 : {
19099 : struct tevent_req *req;
19100 : struct dcerpc_clusapi_CloseNetwork_r_state *state;
19101 : struct tevent_req *subreq;
19102 :
19103 0 : req = tevent_req_create(mem_ctx, &state,
19104 : struct dcerpc_clusapi_CloseNetwork_r_state);
19105 0 : if (req == NULL) {
19106 0 : return NULL;
19107 : }
19108 :
19109 0 : state->out_mem_ctx = talloc_new(state);
19110 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19111 0 : return tevent_req_post(req, ev);
19112 : }
19113 :
19114 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
19115 : NULL, &ndr_table_clusapi,
19116 0 : NDR_CLUSAPI_CLOSENETWORK, state->out_mem_ctx, r);
19117 0 : if (tevent_req_nomem(subreq, req)) {
19118 0 : return tevent_req_post(req, ev);
19119 : }
19120 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNetwork_r_done, req);
19121 :
19122 0 : return req;
19123 : }
19124 :
19125 0 : static void dcerpc_clusapi_CloseNetwork_r_done(struct tevent_req *subreq)
19126 : {
19127 0 : struct tevent_req *req =
19128 0 : tevent_req_callback_data(subreq,
19129 : struct tevent_req);
19130 : NTSTATUS status;
19131 :
19132 0 : status = dcerpc_binding_handle_call_recv(subreq);
19133 0 : TALLOC_FREE(subreq);
19134 0 : if (tevent_req_nterror(req, status)) {
19135 0 : return;
19136 : }
19137 :
19138 0 : tevent_req_done(req);
19139 : }
19140 :
19141 0 : NTSTATUS dcerpc_clusapi_CloseNetwork_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
19142 : {
19143 0 : struct dcerpc_clusapi_CloseNetwork_r_state *state =
19144 0 : tevent_req_data(req,
19145 : struct dcerpc_clusapi_CloseNetwork_r_state);
19146 : NTSTATUS status;
19147 :
19148 0 : if (tevent_req_is_nterror(req, &status)) {
19149 0 : tevent_req_received(req);
19150 0 : return status;
19151 : }
19152 :
19153 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19154 :
19155 0 : tevent_req_received(req);
19156 0 : return NT_STATUS_OK;
19157 : }
19158 :
19159 0 : NTSTATUS dcerpc_clusapi_CloseNetwork_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseNetwork *r)
19160 : {
19161 : NTSTATUS status;
19162 :
19163 0 : status = dcerpc_binding_handle_call(h,
19164 : NULL, &ndr_table_clusapi,
19165 : NDR_CLUSAPI_CLOSENETWORK, mem_ctx, r);
19166 :
19167 0 : return status;
19168 : }
19169 :
19170 : struct dcerpc_clusapi_CloseNetwork_state {
19171 : struct clusapi_CloseNetwork orig;
19172 : struct clusapi_CloseNetwork tmp;
19173 : TALLOC_CTX *out_mem_ctx;
19174 : };
19175 :
19176 : static void dcerpc_clusapi_CloseNetwork_done(struct tevent_req *subreq);
19177 :
19178 0 : struct tevent_req *dcerpc_clusapi_CloseNetwork_send(TALLOC_CTX *mem_ctx,
19179 : struct tevent_context *ev,
19180 : struct dcerpc_binding_handle *h,
19181 : struct policy_handle *_Network /* [in,out] [ref] */)
19182 : {
19183 : struct tevent_req *req;
19184 : struct dcerpc_clusapi_CloseNetwork_state *state;
19185 : struct tevent_req *subreq;
19186 :
19187 0 : req = tevent_req_create(mem_ctx, &state,
19188 : struct dcerpc_clusapi_CloseNetwork_state);
19189 0 : if (req == NULL) {
19190 0 : return NULL;
19191 : }
19192 0 : state->out_mem_ctx = NULL;
19193 :
19194 : /* In parameters */
19195 0 : state->orig.in.Network = _Network;
19196 :
19197 : /* Out parameters */
19198 0 : state->orig.out.Network = _Network;
19199 :
19200 : /* Result */
19201 0 : NDR_ZERO_STRUCT(state->orig.out.result);
19202 :
19203 0 : state->out_mem_ctx = talloc_named_const(state, 0,
19204 : "dcerpc_clusapi_CloseNetwork_out_memory");
19205 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19206 0 : return tevent_req_post(req, ev);
19207 : }
19208 :
19209 : /* make a temporary copy, that we pass to the dispatch function */
19210 0 : state->tmp = state->orig;
19211 :
19212 0 : subreq = dcerpc_clusapi_CloseNetwork_r_send(state, ev, h, &state->tmp);
19213 0 : if (tevent_req_nomem(subreq, req)) {
19214 0 : return tevent_req_post(req, ev);
19215 : }
19216 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNetwork_done, req);
19217 0 : return req;
19218 : }
19219 :
19220 0 : static void dcerpc_clusapi_CloseNetwork_done(struct tevent_req *subreq)
19221 : {
19222 0 : struct tevent_req *req = tevent_req_callback_data(
19223 : subreq, struct tevent_req);
19224 0 : struct dcerpc_clusapi_CloseNetwork_state *state = tevent_req_data(
19225 : req, struct dcerpc_clusapi_CloseNetwork_state);
19226 : NTSTATUS status;
19227 : TALLOC_CTX *mem_ctx;
19228 :
19229 0 : if (state->out_mem_ctx) {
19230 0 : mem_ctx = state->out_mem_ctx;
19231 : } else {
19232 0 : mem_ctx = state;
19233 : }
19234 :
19235 0 : status = dcerpc_clusapi_CloseNetwork_r_recv(subreq, mem_ctx);
19236 0 : TALLOC_FREE(subreq);
19237 0 : if (tevent_req_nterror(req, status)) {
19238 0 : return;
19239 : }
19240 :
19241 : /* Copy out parameters */
19242 0 : *state->orig.out.Network = *state->tmp.out.Network;
19243 :
19244 : /* Copy result */
19245 0 : state->orig.out.result = state->tmp.out.result;
19246 :
19247 : /* Reset temporary structure */
19248 0 : NDR_ZERO_STRUCT(state->tmp);
19249 :
19250 0 : tevent_req_done(req);
19251 : }
19252 :
19253 0 : NTSTATUS dcerpc_clusapi_CloseNetwork_recv(struct tevent_req *req,
19254 : TALLOC_CTX *mem_ctx,
19255 : WERROR *result)
19256 : {
19257 0 : struct dcerpc_clusapi_CloseNetwork_state *state = tevent_req_data(
19258 : req, struct dcerpc_clusapi_CloseNetwork_state);
19259 : NTSTATUS status;
19260 :
19261 0 : if (tevent_req_is_nterror(req, &status)) {
19262 0 : tevent_req_received(req);
19263 0 : return status;
19264 : }
19265 :
19266 : /* Steal possible out parameters to the callers context */
19267 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19268 :
19269 : /* Return result */
19270 0 : *result = state->orig.out.result;
19271 :
19272 0 : tevent_req_received(req);
19273 0 : return NT_STATUS_OK;
19274 : }
19275 :
19276 0 : NTSTATUS dcerpc_clusapi_CloseNetwork(struct dcerpc_binding_handle *h,
19277 : TALLOC_CTX *mem_ctx,
19278 : struct policy_handle *_Network /* [in,out] [ref] */,
19279 : WERROR *result)
19280 : {
19281 : struct clusapi_CloseNetwork r;
19282 : NTSTATUS status;
19283 :
19284 : /* In parameters */
19285 0 : r.in.Network = _Network;
19286 :
19287 : /* Out parameters */
19288 0 : r.out.Network = _Network;
19289 :
19290 : /* Result */
19291 0 : NDR_ZERO_STRUCT(r.out.result);
19292 :
19293 0 : status = dcerpc_clusapi_CloseNetwork_r(h, mem_ctx, &r);
19294 0 : if (!NT_STATUS_IS_OK(status)) {
19295 0 : return status;
19296 : }
19297 :
19298 : /* Return variables */
19299 0 : *_Network = *r.out.Network;
19300 :
19301 : /* Return result */
19302 0 : *result = r.out.result;
19303 :
19304 0 : return NT_STATUS_OK;
19305 : }
19306 :
19307 : struct dcerpc_clusapi_GetNetworkState_r_state {
19308 : TALLOC_CTX *out_mem_ctx;
19309 : };
19310 :
19311 : static void dcerpc_clusapi_GetNetworkState_r_done(struct tevent_req *subreq);
19312 :
19313 0 : struct tevent_req *dcerpc_clusapi_GetNetworkState_r_send(TALLOC_CTX *mem_ctx,
19314 : struct tevent_context *ev,
19315 : struct dcerpc_binding_handle *h,
19316 : struct clusapi_GetNetworkState *r)
19317 : {
19318 : struct tevent_req *req;
19319 : struct dcerpc_clusapi_GetNetworkState_r_state *state;
19320 : struct tevent_req *subreq;
19321 :
19322 0 : req = tevent_req_create(mem_ctx, &state,
19323 : struct dcerpc_clusapi_GetNetworkState_r_state);
19324 0 : if (req == NULL) {
19325 0 : return NULL;
19326 : }
19327 :
19328 0 : state->out_mem_ctx = talloc_new(state);
19329 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19330 0 : return tevent_req_post(req, ev);
19331 : }
19332 :
19333 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
19334 : NULL, &ndr_table_clusapi,
19335 0 : NDR_CLUSAPI_GETNETWORKSTATE, state->out_mem_ctx, r);
19336 0 : if (tevent_req_nomem(subreq, req)) {
19337 0 : return tevent_req_post(req, ev);
19338 : }
19339 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetworkState_r_done, req);
19340 :
19341 0 : return req;
19342 : }
19343 :
19344 0 : static void dcerpc_clusapi_GetNetworkState_r_done(struct tevent_req *subreq)
19345 : {
19346 0 : struct tevent_req *req =
19347 0 : tevent_req_callback_data(subreq,
19348 : struct tevent_req);
19349 : NTSTATUS status;
19350 :
19351 0 : status = dcerpc_binding_handle_call_recv(subreq);
19352 0 : TALLOC_FREE(subreq);
19353 0 : if (tevent_req_nterror(req, status)) {
19354 0 : return;
19355 : }
19356 :
19357 0 : tevent_req_done(req);
19358 : }
19359 :
19360 0 : NTSTATUS dcerpc_clusapi_GetNetworkState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
19361 : {
19362 0 : struct dcerpc_clusapi_GetNetworkState_r_state *state =
19363 0 : tevent_req_data(req,
19364 : struct dcerpc_clusapi_GetNetworkState_r_state);
19365 : NTSTATUS status;
19366 :
19367 0 : if (tevent_req_is_nterror(req, &status)) {
19368 0 : tevent_req_received(req);
19369 0 : return status;
19370 : }
19371 :
19372 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19373 :
19374 0 : tevent_req_received(req);
19375 0 : return NT_STATUS_OK;
19376 : }
19377 :
19378 0 : NTSTATUS dcerpc_clusapi_GetNetworkState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNetworkState *r)
19379 : {
19380 : NTSTATUS status;
19381 :
19382 0 : status = dcerpc_binding_handle_call(h,
19383 : NULL, &ndr_table_clusapi,
19384 : NDR_CLUSAPI_GETNETWORKSTATE, mem_ctx, r);
19385 :
19386 0 : return status;
19387 : }
19388 :
19389 : struct dcerpc_clusapi_GetNetworkState_state {
19390 : struct clusapi_GetNetworkState orig;
19391 : struct clusapi_GetNetworkState tmp;
19392 : TALLOC_CTX *out_mem_ctx;
19393 : };
19394 :
19395 : static void dcerpc_clusapi_GetNetworkState_done(struct tevent_req *subreq);
19396 :
19397 0 : struct tevent_req *dcerpc_clusapi_GetNetworkState_send(TALLOC_CTX *mem_ctx,
19398 : struct tevent_context *ev,
19399 : struct dcerpc_binding_handle *h,
19400 : struct policy_handle _hNetwork /* [in] */,
19401 : enum clusapi_ClusterNetworkState *_State /* [out] [ref] */,
19402 : WERROR *_rpc_status /* [out] [ref] */)
19403 : {
19404 : struct tevent_req *req;
19405 : struct dcerpc_clusapi_GetNetworkState_state *state;
19406 : struct tevent_req *subreq;
19407 :
19408 0 : req = tevent_req_create(mem_ctx, &state,
19409 : struct dcerpc_clusapi_GetNetworkState_state);
19410 0 : if (req == NULL) {
19411 0 : return NULL;
19412 : }
19413 0 : state->out_mem_ctx = NULL;
19414 :
19415 : /* In parameters */
19416 0 : state->orig.in.hNetwork = _hNetwork;
19417 :
19418 : /* Out parameters */
19419 0 : state->orig.out.State = _State;
19420 0 : state->orig.out.rpc_status = _rpc_status;
19421 :
19422 : /* Result */
19423 0 : NDR_ZERO_STRUCT(state->orig.out.result);
19424 :
19425 0 : state->out_mem_ctx = talloc_named_const(state, 0,
19426 : "dcerpc_clusapi_GetNetworkState_out_memory");
19427 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19428 0 : return tevent_req_post(req, ev);
19429 : }
19430 :
19431 : /* make a temporary copy, that we pass to the dispatch function */
19432 0 : state->tmp = state->orig;
19433 :
19434 0 : subreq = dcerpc_clusapi_GetNetworkState_r_send(state, ev, h, &state->tmp);
19435 0 : if (tevent_req_nomem(subreq, req)) {
19436 0 : return tevent_req_post(req, ev);
19437 : }
19438 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetworkState_done, req);
19439 0 : return req;
19440 : }
19441 :
19442 0 : static void dcerpc_clusapi_GetNetworkState_done(struct tevent_req *subreq)
19443 : {
19444 0 : struct tevent_req *req = tevent_req_callback_data(
19445 : subreq, struct tevent_req);
19446 0 : struct dcerpc_clusapi_GetNetworkState_state *state = tevent_req_data(
19447 : req, struct dcerpc_clusapi_GetNetworkState_state);
19448 : NTSTATUS status;
19449 : TALLOC_CTX *mem_ctx;
19450 :
19451 0 : if (state->out_mem_ctx) {
19452 0 : mem_ctx = state->out_mem_ctx;
19453 : } else {
19454 0 : mem_ctx = state;
19455 : }
19456 :
19457 0 : status = dcerpc_clusapi_GetNetworkState_r_recv(subreq, mem_ctx);
19458 0 : TALLOC_FREE(subreq);
19459 0 : if (tevent_req_nterror(req, status)) {
19460 0 : return;
19461 : }
19462 :
19463 : /* Copy out parameters */
19464 0 : *state->orig.out.State = *state->tmp.out.State;
19465 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
19466 :
19467 : /* Copy result */
19468 0 : state->orig.out.result = state->tmp.out.result;
19469 :
19470 : /* Reset temporary structure */
19471 0 : NDR_ZERO_STRUCT(state->tmp);
19472 :
19473 0 : tevent_req_done(req);
19474 : }
19475 :
19476 0 : NTSTATUS dcerpc_clusapi_GetNetworkState_recv(struct tevent_req *req,
19477 : TALLOC_CTX *mem_ctx,
19478 : WERROR *result)
19479 : {
19480 0 : struct dcerpc_clusapi_GetNetworkState_state *state = tevent_req_data(
19481 : req, struct dcerpc_clusapi_GetNetworkState_state);
19482 : NTSTATUS status;
19483 :
19484 0 : if (tevent_req_is_nterror(req, &status)) {
19485 0 : tevent_req_received(req);
19486 0 : return status;
19487 : }
19488 :
19489 : /* Steal possible out parameters to the callers context */
19490 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19491 :
19492 : /* Return result */
19493 0 : *result = state->orig.out.result;
19494 :
19495 0 : tevent_req_received(req);
19496 0 : return NT_STATUS_OK;
19497 : }
19498 :
19499 0 : NTSTATUS dcerpc_clusapi_GetNetworkState(struct dcerpc_binding_handle *h,
19500 : TALLOC_CTX *mem_ctx,
19501 : struct policy_handle _hNetwork /* [in] */,
19502 : enum clusapi_ClusterNetworkState *_State /* [out] [ref] */,
19503 : WERROR *_rpc_status /* [out] [ref] */,
19504 : WERROR *result)
19505 : {
19506 : struct clusapi_GetNetworkState r;
19507 : NTSTATUS status;
19508 :
19509 : /* In parameters */
19510 0 : r.in.hNetwork = _hNetwork;
19511 :
19512 : /* Out parameters */
19513 0 : r.out.State = _State;
19514 0 : r.out.rpc_status = _rpc_status;
19515 :
19516 : /* Result */
19517 0 : NDR_ZERO_STRUCT(r.out.result);
19518 :
19519 0 : status = dcerpc_clusapi_GetNetworkState_r(h, mem_ctx, &r);
19520 0 : if (!NT_STATUS_IS_OK(status)) {
19521 0 : return status;
19522 : }
19523 :
19524 : /* Return variables */
19525 0 : *_State = *r.out.State;
19526 0 : *_rpc_status = *r.out.rpc_status;
19527 :
19528 : /* Return result */
19529 0 : *result = r.out.result;
19530 :
19531 0 : return NT_STATUS_OK;
19532 : }
19533 :
19534 : struct dcerpc_clusapi_SetNetworkName_r_state {
19535 : TALLOC_CTX *out_mem_ctx;
19536 : };
19537 :
19538 : static void dcerpc_clusapi_SetNetworkName_r_done(struct tevent_req *subreq);
19539 :
19540 0 : struct tevent_req *dcerpc_clusapi_SetNetworkName_r_send(TALLOC_CTX *mem_ctx,
19541 : struct tevent_context *ev,
19542 : struct dcerpc_binding_handle *h,
19543 : struct clusapi_SetNetworkName *r)
19544 : {
19545 : struct tevent_req *req;
19546 : struct dcerpc_clusapi_SetNetworkName_r_state *state;
19547 : struct tevent_req *subreq;
19548 :
19549 0 : req = tevent_req_create(mem_ctx, &state,
19550 : struct dcerpc_clusapi_SetNetworkName_r_state);
19551 0 : if (req == NULL) {
19552 0 : return NULL;
19553 : }
19554 :
19555 0 : state->out_mem_ctx = talloc_new(state);
19556 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19557 0 : return tevent_req_post(req, ev);
19558 : }
19559 :
19560 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
19561 : NULL, &ndr_table_clusapi,
19562 0 : NDR_CLUSAPI_SETNETWORKNAME, state->out_mem_ctx, r);
19563 0 : if (tevent_req_nomem(subreq, req)) {
19564 0 : return tevent_req_post(req, ev);
19565 : }
19566 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetNetworkName_r_done, req);
19567 :
19568 0 : return req;
19569 : }
19570 :
19571 0 : static void dcerpc_clusapi_SetNetworkName_r_done(struct tevent_req *subreq)
19572 : {
19573 0 : struct tevent_req *req =
19574 0 : tevent_req_callback_data(subreq,
19575 : struct tevent_req);
19576 : NTSTATUS status;
19577 :
19578 0 : status = dcerpc_binding_handle_call_recv(subreq);
19579 0 : TALLOC_FREE(subreq);
19580 0 : if (tevent_req_nterror(req, status)) {
19581 0 : return;
19582 : }
19583 :
19584 0 : tevent_req_done(req);
19585 : }
19586 :
19587 0 : NTSTATUS dcerpc_clusapi_SetNetworkName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
19588 : {
19589 0 : struct dcerpc_clusapi_SetNetworkName_r_state *state =
19590 0 : tevent_req_data(req,
19591 : struct dcerpc_clusapi_SetNetworkName_r_state);
19592 : NTSTATUS status;
19593 :
19594 0 : if (tevent_req_is_nterror(req, &status)) {
19595 0 : tevent_req_received(req);
19596 0 : return status;
19597 : }
19598 :
19599 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19600 :
19601 0 : tevent_req_received(req);
19602 0 : return NT_STATUS_OK;
19603 : }
19604 :
19605 0 : NTSTATUS dcerpc_clusapi_SetNetworkName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetNetworkName *r)
19606 : {
19607 : NTSTATUS status;
19608 :
19609 0 : status = dcerpc_binding_handle_call(h,
19610 : NULL, &ndr_table_clusapi,
19611 : NDR_CLUSAPI_SETNETWORKNAME, mem_ctx, r);
19612 :
19613 0 : return status;
19614 : }
19615 :
19616 : struct dcerpc_clusapi_SetNetworkName_state {
19617 : struct clusapi_SetNetworkName orig;
19618 : struct clusapi_SetNetworkName tmp;
19619 : TALLOC_CTX *out_mem_ctx;
19620 : };
19621 :
19622 : static void dcerpc_clusapi_SetNetworkName_done(struct tevent_req *subreq);
19623 :
19624 0 : struct tevent_req *dcerpc_clusapi_SetNetworkName_send(TALLOC_CTX *mem_ctx,
19625 : struct tevent_context *ev,
19626 : struct dcerpc_binding_handle *h,
19627 : struct policy_handle _hNetwork /* [in] */,
19628 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
19629 : WERROR *_rpc_status /* [out] [ref] */)
19630 : {
19631 : struct tevent_req *req;
19632 : struct dcerpc_clusapi_SetNetworkName_state *state;
19633 : struct tevent_req *subreq;
19634 :
19635 0 : req = tevent_req_create(mem_ctx, &state,
19636 : struct dcerpc_clusapi_SetNetworkName_state);
19637 0 : if (req == NULL) {
19638 0 : return NULL;
19639 : }
19640 0 : state->out_mem_ctx = NULL;
19641 :
19642 : /* In parameters */
19643 0 : state->orig.in.hNetwork = _hNetwork;
19644 0 : state->orig.in.lpszNetworkName = _lpszNetworkName;
19645 :
19646 : /* Out parameters */
19647 0 : state->orig.out.rpc_status = _rpc_status;
19648 :
19649 : /* Result */
19650 0 : NDR_ZERO_STRUCT(state->orig.out.result);
19651 :
19652 0 : state->out_mem_ctx = talloc_named_const(state, 0,
19653 : "dcerpc_clusapi_SetNetworkName_out_memory");
19654 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19655 0 : return tevent_req_post(req, ev);
19656 : }
19657 :
19658 : /* make a temporary copy, that we pass to the dispatch function */
19659 0 : state->tmp = state->orig;
19660 :
19661 0 : subreq = dcerpc_clusapi_SetNetworkName_r_send(state, ev, h, &state->tmp);
19662 0 : if (tevent_req_nomem(subreq, req)) {
19663 0 : return tevent_req_post(req, ev);
19664 : }
19665 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetNetworkName_done, req);
19666 0 : return req;
19667 : }
19668 :
19669 0 : static void dcerpc_clusapi_SetNetworkName_done(struct tevent_req *subreq)
19670 : {
19671 0 : struct tevent_req *req = tevent_req_callback_data(
19672 : subreq, struct tevent_req);
19673 0 : struct dcerpc_clusapi_SetNetworkName_state *state = tevent_req_data(
19674 : req, struct dcerpc_clusapi_SetNetworkName_state);
19675 : NTSTATUS status;
19676 : TALLOC_CTX *mem_ctx;
19677 :
19678 0 : if (state->out_mem_ctx) {
19679 0 : mem_ctx = state->out_mem_ctx;
19680 : } else {
19681 0 : mem_ctx = state;
19682 : }
19683 :
19684 0 : status = dcerpc_clusapi_SetNetworkName_r_recv(subreq, mem_ctx);
19685 0 : TALLOC_FREE(subreq);
19686 0 : if (tevent_req_nterror(req, status)) {
19687 0 : return;
19688 : }
19689 :
19690 : /* Copy out parameters */
19691 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
19692 :
19693 : /* Copy result */
19694 0 : state->orig.out.result = state->tmp.out.result;
19695 :
19696 : /* Reset temporary structure */
19697 0 : NDR_ZERO_STRUCT(state->tmp);
19698 :
19699 0 : tevent_req_done(req);
19700 : }
19701 :
19702 0 : NTSTATUS dcerpc_clusapi_SetNetworkName_recv(struct tevent_req *req,
19703 : TALLOC_CTX *mem_ctx,
19704 : WERROR *result)
19705 : {
19706 0 : struct dcerpc_clusapi_SetNetworkName_state *state = tevent_req_data(
19707 : req, struct dcerpc_clusapi_SetNetworkName_state);
19708 : NTSTATUS status;
19709 :
19710 0 : if (tevent_req_is_nterror(req, &status)) {
19711 0 : tevent_req_received(req);
19712 0 : return status;
19713 : }
19714 :
19715 : /* Steal possible out parameters to the callers context */
19716 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19717 :
19718 : /* Return result */
19719 0 : *result = state->orig.out.result;
19720 :
19721 0 : tevent_req_received(req);
19722 0 : return NT_STATUS_OK;
19723 : }
19724 :
19725 0 : NTSTATUS dcerpc_clusapi_SetNetworkName(struct dcerpc_binding_handle *h,
19726 : TALLOC_CTX *mem_ctx,
19727 : struct policy_handle _hNetwork /* [in] */,
19728 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
19729 : WERROR *_rpc_status /* [out] [ref] */,
19730 : WERROR *result)
19731 : {
19732 : struct clusapi_SetNetworkName r;
19733 : NTSTATUS status;
19734 :
19735 : /* In parameters */
19736 0 : r.in.hNetwork = _hNetwork;
19737 0 : r.in.lpszNetworkName = _lpszNetworkName;
19738 :
19739 : /* Out parameters */
19740 0 : r.out.rpc_status = _rpc_status;
19741 :
19742 : /* Result */
19743 0 : NDR_ZERO_STRUCT(r.out.result);
19744 :
19745 0 : status = dcerpc_clusapi_SetNetworkName_r(h, mem_ctx, &r);
19746 0 : if (!NT_STATUS_IS_OK(status)) {
19747 0 : return status;
19748 : }
19749 :
19750 : /* Return variables */
19751 0 : *_rpc_status = *r.out.rpc_status;
19752 :
19753 : /* Return result */
19754 0 : *result = r.out.result;
19755 :
19756 0 : return NT_STATUS_OK;
19757 : }
19758 :
19759 : struct dcerpc_clusapi_CreateNetworkEnum_r_state {
19760 : TALLOC_CTX *out_mem_ctx;
19761 : };
19762 :
19763 : static void dcerpc_clusapi_CreateNetworkEnum_r_done(struct tevent_req *subreq);
19764 :
19765 0 : struct tevent_req *dcerpc_clusapi_CreateNetworkEnum_r_send(TALLOC_CTX *mem_ctx,
19766 : struct tevent_context *ev,
19767 : struct dcerpc_binding_handle *h,
19768 : struct clusapi_CreateNetworkEnum *r)
19769 : {
19770 : struct tevent_req *req;
19771 : struct dcerpc_clusapi_CreateNetworkEnum_r_state *state;
19772 : struct tevent_req *subreq;
19773 :
19774 0 : req = tevent_req_create(mem_ctx, &state,
19775 : struct dcerpc_clusapi_CreateNetworkEnum_r_state);
19776 0 : if (req == NULL) {
19777 0 : return NULL;
19778 : }
19779 :
19780 0 : state->out_mem_ctx = talloc_new(state);
19781 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19782 0 : return tevent_req_post(req, ev);
19783 : }
19784 :
19785 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
19786 : NULL, &ndr_table_clusapi,
19787 0 : NDR_CLUSAPI_CREATENETWORKENUM, state->out_mem_ctx, r);
19788 0 : if (tevent_req_nomem(subreq, req)) {
19789 0 : return tevent_req_post(req, ev);
19790 : }
19791 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNetworkEnum_r_done, req);
19792 :
19793 0 : return req;
19794 : }
19795 :
19796 0 : static void dcerpc_clusapi_CreateNetworkEnum_r_done(struct tevent_req *subreq)
19797 : {
19798 0 : struct tevent_req *req =
19799 0 : tevent_req_callback_data(subreq,
19800 : struct tevent_req);
19801 : NTSTATUS status;
19802 :
19803 0 : status = dcerpc_binding_handle_call_recv(subreq);
19804 0 : TALLOC_FREE(subreq);
19805 0 : if (tevent_req_nterror(req, status)) {
19806 0 : return;
19807 : }
19808 :
19809 0 : tevent_req_done(req);
19810 : }
19811 :
19812 0 : NTSTATUS dcerpc_clusapi_CreateNetworkEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
19813 : {
19814 0 : struct dcerpc_clusapi_CreateNetworkEnum_r_state *state =
19815 0 : tevent_req_data(req,
19816 : struct dcerpc_clusapi_CreateNetworkEnum_r_state);
19817 : NTSTATUS status;
19818 :
19819 0 : if (tevent_req_is_nterror(req, &status)) {
19820 0 : tevent_req_received(req);
19821 0 : return status;
19822 : }
19823 :
19824 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19825 :
19826 0 : tevent_req_received(req);
19827 0 : return NT_STATUS_OK;
19828 : }
19829 :
19830 0 : NTSTATUS dcerpc_clusapi_CreateNetworkEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNetworkEnum *r)
19831 : {
19832 : NTSTATUS status;
19833 :
19834 0 : status = dcerpc_binding_handle_call(h,
19835 : NULL, &ndr_table_clusapi,
19836 : NDR_CLUSAPI_CREATENETWORKENUM, mem_ctx, r);
19837 :
19838 0 : return status;
19839 : }
19840 :
19841 : struct dcerpc_clusapi_CreateNetworkEnum_state {
19842 : struct clusapi_CreateNetworkEnum orig;
19843 : struct clusapi_CreateNetworkEnum tmp;
19844 : TALLOC_CTX *out_mem_ctx;
19845 : };
19846 :
19847 : static void dcerpc_clusapi_CreateNetworkEnum_done(struct tevent_req *subreq);
19848 :
19849 0 : struct tevent_req *dcerpc_clusapi_CreateNetworkEnum_send(TALLOC_CTX *mem_ctx,
19850 : struct tevent_context *ev,
19851 : struct dcerpc_binding_handle *h,
19852 : struct policy_handle _hNetwork /* [in] */,
19853 : uint32_t _dwType /* [in] */,
19854 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
19855 : WERROR *_rpc_status /* [out] [ref] */)
19856 : {
19857 : struct tevent_req *req;
19858 : struct dcerpc_clusapi_CreateNetworkEnum_state *state;
19859 : struct tevent_req *subreq;
19860 :
19861 0 : req = tevent_req_create(mem_ctx, &state,
19862 : struct dcerpc_clusapi_CreateNetworkEnum_state);
19863 0 : if (req == NULL) {
19864 0 : return NULL;
19865 : }
19866 0 : state->out_mem_ctx = NULL;
19867 :
19868 : /* In parameters */
19869 0 : state->orig.in.hNetwork = _hNetwork;
19870 0 : state->orig.in.dwType = _dwType;
19871 :
19872 : /* Out parameters */
19873 0 : state->orig.out.ReturnEnum = _ReturnEnum;
19874 0 : state->orig.out.rpc_status = _rpc_status;
19875 :
19876 : /* Result */
19877 0 : NDR_ZERO_STRUCT(state->orig.out.result);
19878 :
19879 0 : state->out_mem_ctx = talloc_named_const(state, 0,
19880 : "dcerpc_clusapi_CreateNetworkEnum_out_memory");
19881 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
19882 0 : return tevent_req_post(req, ev);
19883 : }
19884 :
19885 : /* make a temporary copy, that we pass to the dispatch function */
19886 0 : state->tmp = state->orig;
19887 :
19888 0 : subreq = dcerpc_clusapi_CreateNetworkEnum_r_send(state, ev, h, &state->tmp);
19889 0 : if (tevent_req_nomem(subreq, req)) {
19890 0 : return tevent_req_post(req, ev);
19891 : }
19892 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNetworkEnum_done, req);
19893 0 : return req;
19894 : }
19895 :
19896 0 : static void dcerpc_clusapi_CreateNetworkEnum_done(struct tevent_req *subreq)
19897 : {
19898 0 : struct tevent_req *req = tevent_req_callback_data(
19899 : subreq, struct tevent_req);
19900 0 : struct dcerpc_clusapi_CreateNetworkEnum_state *state = tevent_req_data(
19901 : req, struct dcerpc_clusapi_CreateNetworkEnum_state);
19902 : NTSTATUS status;
19903 : TALLOC_CTX *mem_ctx;
19904 :
19905 0 : if (state->out_mem_ctx) {
19906 0 : mem_ctx = state->out_mem_ctx;
19907 : } else {
19908 0 : mem_ctx = state;
19909 : }
19910 :
19911 0 : status = dcerpc_clusapi_CreateNetworkEnum_r_recv(subreq, mem_ctx);
19912 0 : TALLOC_FREE(subreq);
19913 0 : if (tevent_req_nterror(req, status)) {
19914 0 : return;
19915 : }
19916 :
19917 : /* Copy out parameters */
19918 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
19919 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
19920 :
19921 : /* Copy result */
19922 0 : state->orig.out.result = state->tmp.out.result;
19923 :
19924 : /* Reset temporary structure */
19925 0 : NDR_ZERO_STRUCT(state->tmp);
19926 :
19927 0 : tevent_req_done(req);
19928 : }
19929 :
19930 0 : NTSTATUS dcerpc_clusapi_CreateNetworkEnum_recv(struct tevent_req *req,
19931 : TALLOC_CTX *mem_ctx,
19932 : WERROR *result)
19933 : {
19934 0 : struct dcerpc_clusapi_CreateNetworkEnum_state *state = tevent_req_data(
19935 : req, struct dcerpc_clusapi_CreateNetworkEnum_state);
19936 : NTSTATUS status;
19937 :
19938 0 : if (tevent_req_is_nterror(req, &status)) {
19939 0 : tevent_req_received(req);
19940 0 : return status;
19941 : }
19942 :
19943 : /* Steal possible out parameters to the callers context */
19944 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
19945 :
19946 : /* Return result */
19947 0 : *result = state->orig.out.result;
19948 :
19949 0 : tevent_req_received(req);
19950 0 : return NT_STATUS_OK;
19951 : }
19952 :
19953 0 : NTSTATUS dcerpc_clusapi_CreateNetworkEnum(struct dcerpc_binding_handle *h,
19954 : TALLOC_CTX *mem_ctx,
19955 : struct policy_handle _hNetwork /* [in] */,
19956 : uint32_t _dwType /* [in] */,
19957 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
19958 : WERROR *_rpc_status /* [out] [ref] */,
19959 : WERROR *result)
19960 : {
19961 : struct clusapi_CreateNetworkEnum r;
19962 : NTSTATUS status;
19963 :
19964 : /* In parameters */
19965 0 : r.in.hNetwork = _hNetwork;
19966 0 : r.in.dwType = _dwType;
19967 :
19968 : /* Out parameters */
19969 0 : r.out.ReturnEnum = _ReturnEnum;
19970 0 : r.out.rpc_status = _rpc_status;
19971 :
19972 : /* Result */
19973 0 : NDR_ZERO_STRUCT(r.out.result);
19974 :
19975 0 : status = dcerpc_clusapi_CreateNetworkEnum_r(h, mem_ctx, &r);
19976 0 : if (!NT_STATUS_IS_OK(status)) {
19977 0 : return status;
19978 : }
19979 :
19980 : /* Return variables */
19981 0 : *_ReturnEnum = *r.out.ReturnEnum;
19982 0 : *_rpc_status = *r.out.rpc_status;
19983 :
19984 : /* Return result */
19985 0 : *result = r.out.result;
19986 :
19987 0 : return NT_STATUS_OK;
19988 : }
19989 :
19990 : struct dcerpc_clusapi_GetNetworkId_r_state {
19991 : TALLOC_CTX *out_mem_ctx;
19992 : };
19993 :
19994 : static void dcerpc_clusapi_GetNetworkId_r_done(struct tevent_req *subreq);
19995 :
19996 0 : struct tevent_req *dcerpc_clusapi_GetNetworkId_r_send(TALLOC_CTX *mem_ctx,
19997 : struct tevent_context *ev,
19998 : struct dcerpc_binding_handle *h,
19999 : struct clusapi_GetNetworkId *r)
20000 : {
20001 : struct tevent_req *req;
20002 : struct dcerpc_clusapi_GetNetworkId_r_state *state;
20003 : struct tevent_req *subreq;
20004 :
20005 0 : req = tevent_req_create(mem_ctx, &state,
20006 : struct dcerpc_clusapi_GetNetworkId_r_state);
20007 0 : if (req == NULL) {
20008 0 : return NULL;
20009 : }
20010 :
20011 0 : state->out_mem_ctx = talloc_new(state);
20012 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20013 0 : return tevent_req_post(req, ev);
20014 : }
20015 :
20016 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
20017 : NULL, &ndr_table_clusapi,
20018 0 : NDR_CLUSAPI_GETNETWORKID, state->out_mem_ctx, r);
20019 0 : if (tevent_req_nomem(subreq, req)) {
20020 0 : return tevent_req_post(req, ev);
20021 : }
20022 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetworkId_r_done, req);
20023 :
20024 0 : return req;
20025 : }
20026 :
20027 0 : static void dcerpc_clusapi_GetNetworkId_r_done(struct tevent_req *subreq)
20028 : {
20029 0 : struct tevent_req *req =
20030 0 : tevent_req_callback_data(subreq,
20031 : struct tevent_req);
20032 : NTSTATUS status;
20033 :
20034 0 : status = dcerpc_binding_handle_call_recv(subreq);
20035 0 : TALLOC_FREE(subreq);
20036 0 : if (tevent_req_nterror(req, status)) {
20037 0 : return;
20038 : }
20039 :
20040 0 : tevent_req_done(req);
20041 : }
20042 :
20043 0 : NTSTATUS dcerpc_clusapi_GetNetworkId_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
20044 : {
20045 0 : struct dcerpc_clusapi_GetNetworkId_r_state *state =
20046 0 : tevent_req_data(req,
20047 : struct dcerpc_clusapi_GetNetworkId_r_state);
20048 : NTSTATUS status;
20049 :
20050 0 : if (tevent_req_is_nterror(req, &status)) {
20051 0 : tevent_req_received(req);
20052 0 : return status;
20053 : }
20054 :
20055 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20056 :
20057 0 : tevent_req_received(req);
20058 0 : return NT_STATUS_OK;
20059 : }
20060 :
20061 0 : NTSTATUS dcerpc_clusapi_GetNetworkId_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNetworkId *r)
20062 : {
20063 : NTSTATUS status;
20064 :
20065 0 : status = dcerpc_binding_handle_call(h,
20066 : NULL, &ndr_table_clusapi,
20067 : NDR_CLUSAPI_GETNETWORKID, mem_ctx, r);
20068 :
20069 0 : return status;
20070 : }
20071 :
20072 : struct dcerpc_clusapi_GetNetworkId_state {
20073 : struct clusapi_GetNetworkId orig;
20074 : struct clusapi_GetNetworkId tmp;
20075 : TALLOC_CTX *out_mem_ctx;
20076 : };
20077 :
20078 : static void dcerpc_clusapi_GetNetworkId_done(struct tevent_req *subreq);
20079 :
20080 0 : struct tevent_req *dcerpc_clusapi_GetNetworkId_send(TALLOC_CTX *mem_ctx,
20081 : struct tevent_context *ev,
20082 : struct dcerpc_binding_handle *h,
20083 : struct policy_handle _hNetwork /* [in] */,
20084 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
20085 : WERROR *_rpc_status /* [out] [ref] */)
20086 : {
20087 : struct tevent_req *req;
20088 : struct dcerpc_clusapi_GetNetworkId_state *state;
20089 : struct tevent_req *subreq;
20090 :
20091 0 : req = tevent_req_create(mem_ctx, &state,
20092 : struct dcerpc_clusapi_GetNetworkId_state);
20093 0 : if (req == NULL) {
20094 0 : return NULL;
20095 : }
20096 0 : state->out_mem_ctx = NULL;
20097 :
20098 : /* In parameters */
20099 0 : state->orig.in.hNetwork = _hNetwork;
20100 :
20101 : /* Out parameters */
20102 0 : state->orig.out.pGuid = _pGuid;
20103 0 : state->orig.out.rpc_status = _rpc_status;
20104 :
20105 : /* Result */
20106 0 : NDR_ZERO_STRUCT(state->orig.out.result);
20107 :
20108 0 : state->out_mem_ctx = talloc_named_const(state, 0,
20109 : "dcerpc_clusapi_GetNetworkId_out_memory");
20110 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20111 0 : return tevent_req_post(req, ev);
20112 : }
20113 :
20114 : /* make a temporary copy, that we pass to the dispatch function */
20115 0 : state->tmp = state->orig;
20116 :
20117 0 : subreq = dcerpc_clusapi_GetNetworkId_r_send(state, ev, h, &state->tmp);
20118 0 : if (tevent_req_nomem(subreq, req)) {
20119 0 : return tevent_req_post(req, ev);
20120 : }
20121 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetworkId_done, req);
20122 0 : return req;
20123 : }
20124 :
20125 0 : static void dcerpc_clusapi_GetNetworkId_done(struct tevent_req *subreq)
20126 : {
20127 0 : struct tevent_req *req = tevent_req_callback_data(
20128 : subreq, struct tevent_req);
20129 0 : struct dcerpc_clusapi_GetNetworkId_state *state = tevent_req_data(
20130 : req, struct dcerpc_clusapi_GetNetworkId_state);
20131 : NTSTATUS status;
20132 : TALLOC_CTX *mem_ctx;
20133 :
20134 0 : if (state->out_mem_ctx) {
20135 0 : mem_ctx = state->out_mem_ctx;
20136 : } else {
20137 0 : mem_ctx = state;
20138 : }
20139 :
20140 0 : status = dcerpc_clusapi_GetNetworkId_r_recv(subreq, mem_ctx);
20141 0 : TALLOC_FREE(subreq);
20142 0 : if (tevent_req_nterror(req, status)) {
20143 0 : return;
20144 : }
20145 :
20146 : /* Copy out parameters */
20147 0 : *state->orig.out.pGuid = *state->tmp.out.pGuid;
20148 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
20149 :
20150 : /* Copy result */
20151 0 : state->orig.out.result = state->tmp.out.result;
20152 :
20153 : /* Reset temporary structure */
20154 0 : NDR_ZERO_STRUCT(state->tmp);
20155 :
20156 0 : tevent_req_done(req);
20157 : }
20158 :
20159 0 : NTSTATUS dcerpc_clusapi_GetNetworkId_recv(struct tevent_req *req,
20160 : TALLOC_CTX *mem_ctx,
20161 : WERROR *result)
20162 : {
20163 0 : struct dcerpc_clusapi_GetNetworkId_state *state = tevent_req_data(
20164 : req, struct dcerpc_clusapi_GetNetworkId_state);
20165 : NTSTATUS status;
20166 :
20167 0 : if (tevent_req_is_nterror(req, &status)) {
20168 0 : tevent_req_received(req);
20169 0 : return status;
20170 : }
20171 :
20172 : /* Steal possible out parameters to the callers context */
20173 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20174 :
20175 : /* Return result */
20176 0 : *result = state->orig.out.result;
20177 :
20178 0 : tevent_req_received(req);
20179 0 : return NT_STATUS_OK;
20180 : }
20181 :
20182 0 : NTSTATUS dcerpc_clusapi_GetNetworkId(struct dcerpc_binding_handle *h,
20183 : TALLOC_CTX *mem_ctx,
20184 : struct policy_handle _hNetwork /* [in] */,
20185 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
20186 : WERROR *_rpc_status /* [out] [ref] */,
20187 : WERROR *result)
20188 : {
20189 : struct clusapi_GetNetworkId r;
20190 : NTSTATUS status;
20191 :
20192 : /* In parameters */
20193 0 : r.in.hNetwork = _hNetwork;
20194 :
20195 : /* Out parameters */
20196 0 : r.out.pGuid = _pGuid;
20197 0 : r.out.rpc_status = _rpc_status;
20198 :
20199 : /* Result */
20200 0 : NDR_ZERO_STRUCT(r.out.result);
20201 :
20202 0 : status = dcerpc_clusapi_GetNetworkId_r(h, mem_ctx, &r);
20203 0 : if (!NT_STATUS_IS_OK(status)) {
20204 0 : return status;
20205 : }
20206 :
20207 : /* Return variables */
20208 0 : *_pGuid = *r.out.pGuid;
20209 0 : *_rpc_status = *r.out.rpc_status;
20210 :
20211 : /* Return result */
20212 0 : *result = r.out.result;
20213 :
20214 0 : return NT_STATUS_OK;
20215 : }
20216 :
20217 : struct dcerpc_clusapi_SetNetworkPriorityOrder_r_state {
20218 : TALLOC_CTX *out_mem_ctx;
20219 : };
20220 :
20221 : static void dcerpc_clusapi_SetNetworkPriorityOrder_r_done(struct tevent_req *subreq);
20222 :
20223 0 : struct tevent_req *dcerpc_clusapi_SetNetworkPriorityOrder_r_send(TALLOC_CTX *mem_ctx,
20224 : struct tevent_context *ev,
20225 : struct dcerpc_binding_handle *h,
20226 : struct clusapi_SetNetworkPriorityOrder *r)
20227 : {
20228 : struct tevent_req *req;
20229 : struct dcerpc_clusapi_SetNetworkPriorityOrder_r_state *state;
20230 : struct tevent_req *subreq;
20231 :
20232 0 : req = tevent_req_create(mem_ctx, &state,
20233 : struct dcerpc_clusapi_SetNetworkPriorityOrder_r_state);
20234 0 : if (req == NULL) {
20235 0 : return NULL;
20236 : }
20237 :
20238 0 : state->out_mem_ctx = talloc_new(state);
20239 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20240 0 : return tevent_req_post(req, ev);
20241 : }
20242 :
20243 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
20244 : NULL, &ndr_table_clusapi,
20245 0 : NDR_CLUSAPI_SETNETWORKPRIORITYORDER, state->out_mem_ctx, r);
20246 0 : if (tevent_req_nomem(subreq, req)) {
20247 0 : return tevent_req_post(req, ev);
20248 : }
20249 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetNetworkPriorityOrder_r_done, req);
20250 :
20251 0 : return req;
20252 : }
20253 :
20254 0 : static void dcerpc_clusapi_SetNetworkPriorityOrder_r_done(struct tevent_req *subreq)
20255 : {
20256 0 : struct tevent_req *req =
20257 0 : tevent_req_callback_data(subreq,
20258 : struct tevent_req);
20259 : NTSTATUS status;
20260 :
20261 0 : status = dcerpc_binding_handle_call_recv(subreq);
20262 0 : TALLOC_FREE(subreq);
20263 0 : if (tevent_req_nterror(req, status)) {
20264 0 : return;
20265 : }
20266 :
20267 0 : tevent_req_done(req);
20268 : }
20269 :
20270 0 : NTSTATUS dcerpc_clusapi_SetNetworkPriorityOrder_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
20271 : {
20272 0 : struct dcerpc_clusapi_SetNetworkPriorityOrder_r_state *state =
20273 0 : tevent_req_data(req,
20274 : struct dcerpc_clusapi_SetNetworkPriorityOrder_r_state);
20275 : NTSTATUS status;
20276 :
20277 0 : if (tevent_req_is_nterror(req, &status)) {
20278 0 : tevent_req_received(req);
20279 0 : return status;
20280 : }
20281 :
20282 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20283 :
20284 0 : tevent_req_received(req);
20285 0 : return NT_STATUS_OK;
20286 : }
20287 :
20288 0 : NTSTATUS dcerpc_clusapi_SetNetworkPriorityOrder_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetNetworkPriorityOrder *r)
20289 : {
20290 : NTSTATUS status;
20291 :
20292 0 : status = dcerpc_binding_handle_call(h,
20293 : NULL, &ndr_table_clusapi,
20294 : NDR_CLUSAPI_SETNETWORKPRIORITYORDER, mem_ctx, r);
20295 :
20296 0 : return status;
20297 : }
20298 :
20299 : struct dcerpc_clusapi_SetNetworkPriorityOrder_state {
20300 : struct clusapi_SetNetworkPriorityOrder orig;
20301 : struct clusapi_SetNetworkPriorityOrder tmp;
20302 : TALLOC_CTX *out_mem_ctx;
20303 : };
20304 :
20305 : static void dcerpc_clusapi_SetNetworkPriorityOrder_done(struct tevent_req *subreq);
20306 :
20307 0 : struct tevent_req *dcerpc_clusapi_SetNetworkPriorityOrder_send(TALLOC_CTX *mem_ctx,
20308 : struct tevent_context *ev,
20309 : struct dcerpc_binding_handle *h,
20310 : uint32_t _NetworkCount /* [in] [range(0,1000)] */,
20311 : const char *_NetworkIdList /* [in] [charset(UTF16),size_is(NetworkCount)] */,
20312 : WERROR *_rpc_status /* [out] [ref] */)
20313 : {
20314 : struct tevent_req *req;
20315 : struct dcerpc_clusapi_SetNetworkPriorityOrder_state *state;
20316 : struct tevent_req *subreq;
20317 :
20318 0 : req = tevent_req_create(mem_ctx, &state,
20319 : struct dcerpc_clusapi_SetNetworkPriorityOrder_state);
20320 0 : if (req == NULL) {
20321 0 : return NULL;
20322 : }
20323 0 : state->out_mem_ctx = NULL;
20324 :
20325 : /* In parameters */
20326 0 : state->orig.in.NetworkCount = _NetworkCount;
20327 0 : state->orig.in.NetworkIdList = _NetworkIdList;
20328 :
20329 : /* Out parameters */
20330 0 : state->orig.out.rpc_status = _rpc_status;
20331 :
20332 : /* Result */
20333 0 : NDR_ZERO_STRUCT(state->orig.out.result);
20334 :
20335 0 : state->out_mem_ctx = talloc_named_const(state, 0,
20336 : "dcerpc_clusapi_SetNetworkPriorityOrder_out_memory");
20337 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20338 0 : return tevent_req_post(req, ev);
20339 : }
20340 :
20341 : /* make a temporary copy, that we pass to the dispatch function */
20342 0 : state->tmp = state->orig;
20343 :
20344 0 : subreq = dcerpc_clusapi_SetNetworkPriorityOrder_r_send(state, ev, h, &state->tmp);
20345 0 : if (tevent_req_nomem(subreq, req)) {
20346 0 : return tevent_req_post(req, ev);
20347 : }
20348 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetNetworkPriorityOrder_done, req);
20349 0 : return req;
20350 : }
20351 :
20352 0 : static void dcerpc_clusapi_SetNetworkPriorityOrder_done(struct tevent_req *subreq)
20353 : {
20354 0 : struct tevent_req *req = tevent_req_callback_data(
20355 : subreq, struct tevent_req);
20356 0 : struct dcerpc_clusapi_SetNetworkPriorityOrder_state *state = tevent_req_data(
20357 : req, struct dcerpc_clusapi_SetNetworkPriorityOrder_state);
20358 : NTSTATUS status;
20359 : TALLOC_CTX *mem_ctx;
20360 :
20361 0 : if (state->out_mem_ctx) {
20362 0 : mem_ctx = state->out_mem_ctx;
20363 : } else {
20364 0 : mem_ctx = state;
20365 : }
20366 :
20367 0 : status = dcerpc_clusapi_SetNetworkPriorityOrder_r_recv(subreq, mem_ctx);
20368 0 : TALLOC_FREE(subreq);
20369 0 : if (tevent_req_nterror(req, status)) {
20370 0 : return;
20371 : }
20372 :
20373 : /* Copy out parameters */
20374 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
20375 :
20376 : /* Copy result */
20377 0 : state->orig.out.result = state->tmp.out.result;
20378 :
20379 : /* Reset temporary structure */
20380 0 : NDR_ZERO_STRUCT(state->tmp);
20381 :
20382 0 : tevent_req_done(req);
20383 : }
20384 :
20385 0 : NTSTATUS dcerpc_clusapi_SetNetworkPriorityOrder_recv(struct tevent_req *req,
20386 : TALLOC_CTX *mem_ctx,
20387 : WERROR *result)
20388 : {
20389 0 : struct dcerpc_clusapi_SetNetworkPriorityOrder_state *state = tevent_req_data(
20390 : req, struct dcerpc_clusapi_SetNetworkPriorityOrder_state);
20391 : NTSTATUS status;
20392 :
20393 0 : if (tevent_req_is_nterror(req, &status)) {
20394 0 : tevent_req_received(req);
20395 0 : return status;
20396 : }
20397 :
20398 : /* Steal possible out parameters to the callers context */
20399 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20400 :
20401 : /* Return result */
20402 0 : *result = state->orig.out.result;
20403 :
20404 0 : tevent_req_received(req);
20405 0 : return NT_STATUS_OK;
20406 : }
20407 :
20408 0 : NTSTATUS dcerpc_clusapi_SetNetworkPriorityOrder(struct dcerpc_binding_handle *h,
20409 : TALLOC_CTX *mem_ctx,
20410 : uint32_t _NetworkCount /* [in] [range(0,1000)] */,
20411 : const char *_NetworkIdList /* [in] [charset(UTF16),size_is(NetworkCount)] */,
20412 : WERROR *_rpc_status /* [out] [ref] */,
20413 : WERROR *result)
20414 : {
20415 : struct clusapi_SetNetworkPriorityOrder r;
20416 : NTSTATUS status;
20417 :
20418 : /* In parameters */
20419 0 : r.in.NetworkCount = _NetworkCount;
20420 0 : r.in.NetworkIdList = _NetworkIdList;
20421 :
20422 : /* Out parameters */
20423 0 : r.out.rpc_status = _rpc_status;
20424 :
20425 : /* Result */
20426 0 : NDR_ZERO_STRUCT(r.out.result);
20427 :
20428 0 : status = dcerpc_clusapi_SetNetworkPriorityOrder_r(h, mem_ctx, &r);
20429 0 : if (!NT_STATUS_IS_OK(status)) {
20430 0 : return status;
20431 : }
20432 :
20433 : /* Return variables */
20434 0 : *_rpc_status = *r.out.rpc_status;
20435 :
20436 : /* Return result */
20437 0 : *result = r.out.result;
20438 :
20439 0 : return NT_STATUS_OK;
20440 : }
20441 :
20442 : struct dcerpc_clusapi_NodeNetworkControl_r_state {
20443 : TALLOC_CTX *out_mem_ctx;
20444 : };
20445 :
20446 : static void dcerpc_clusapi_NodeNetworkControl_r_done(struct tevent_req *subreq);
20447 :
20448 0 : struct tevent_req *dcerpc_clusapi_NodeNetworkControl_r_send(TALLOC_CTX *mem_ctx,
20449 : struct tevent_context *ev,
20450 : struct dcerpc_binding_handle *h,
20451 : struct clusapi_NodeNetworkControl *r)
20452 : {
20453 : struct tevent_req *req;
20454 : struct dcerpc_clusapi_NodeNetworkControl_r_state *state;
20455 : struct tevent_req *subreq;
20456 :
20457 0 : req = tevent_req_create(mem_ctx, &state,
20458 : struct dcerpc_clusapi_NodeNetworkControl_r_state);
20459 0 : if (req == NULL) {
20460 0 : return NULL;
20461 : }
20462 :
20463 0 : state->out_mem_ctx = talloc_new(state);
20464 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20465 0 : return tevent_req_post(req, ev);
20466 : }
20467 :
20468 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
20469 : NULL, &ndr_table_clusapi,
20470 0 : NDR_CLUSAPI_NODENETWORKCONTROL, state->out_mem_ctx, r);
20471 0 : if (tevent_req_nomem(subreq, req)) {
20472 0 : return tevent_req_post(req, ev);
20473 : }
20474 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNetworkControl_r_done, req);
20475 :
20476 0 : return req;
20477 : }
20478 :
20479 0 : static void dcerpc_clusapi_NodeNetworkControl_r_done(struct tevent_req *subreq)
20480 : {
20481 0 : struct tevent_req *req =
20482 0 : tevent_req_callback_data(subreq,
20483 : struct tevent_req);
20484 : NTSTATUS status;
20485 :
20486 0 : status = dcerpc_binding_handle_call_recv(subreq);
20487 0 : TALLOC_FREE(subreq);
20488 0 : if (tevent_req_nterror(req, status)) {
20489 0 : return;
20490 : }
20491 :
20492 0 : tevent_req_done(req);
20493 : }
20494 :
20495 0 : NTSTATUS dcerpc_clusapi_NodeNetworkControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
20496 : {
20497 0 : struct dcerpc_clusapi_NodeNetworkControl_r_state *state =
20498 0 : tevent_req_data(req,
20499 : struct dcerpc_clusapi_NodeNetworkControl_r_state);
20500 : NTSTATUS status;
20501 :
20502 0 : if (tevent_req_is_nterror(req, &status)) {
20503 0 : tevent_req_received(req);
20504 0 : return status;
20505 : }
20506 :
20507 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20508 :
20509 0 : tevent_req_received(req);
20510 0 : return NT_STATUS_OK;
20511 : }
20512 :
20513 0 : NTSTATUS dcerpc_clusapi_NodeNetworkControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeNetworkControl *r)
20514 : {
20515 : NTSTATUS status;
20516 :
20517 0 : status = dcerpc_binding_handle_call(h,
20518 : NULL, &ndr_table_clusapi,
20519 : NDR_CLUSAPI_NODENETWORKCONTROL, mem_ctx, r);
20520 :
20521 0 : return status;
20522 : }
20523 :
20524 : struct dcerpc_clusapi_NodeNetworkControl_state {
20525 : struct clusapi_NodeNetworkControl orig;
20526 : struct clusapi_NodeNetworkControl tmp;
20527 : TALLOC_CTX *out_mem_ctx;
20528 : };
20529 :
20530 : static void dcerpc_clusapi_NodeNetworkControl_done(struct tevent_req *subreq);
20531 :
20532 0 : struct tevent_req *dcerpc_clusapi_NodeNetworkControl_send(TALLOC_CTX *mem_ctx,
20533 : struct tevent_context *ev,
20534 : struct dcerpc_binding_handle *h,
20535 : struct policy_handle _hNetwork /* [in] */,
20536 : struct policy_handle _hNode /* [in] */,
20537 : uint32_t _dwControlCode /* [in] */,
20538 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
20539 : uint32_t _nInBufferSize /* [in] */,
20540 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
20541 : uint32_t _nOutBufferSize /* [in] */,
20542 : uint32_t *_lpBytesReturned /* [out] [ref] */,
20543 : uint32_t *_lpcbRequired /* [out] [ref] */,
20544 : WERROR *_rpc_status /* [out] [ref] */)
20545 : {
20546 : struct tevent_req *req;
20547 : struct dcerpc_clusapi_NodeNetworkControl_state *state;
20548 : struct tevent_req *subreq;
20549 :
20550 0 : req = tevent_req_create(mem_ctx, &state,
20551 : struct dcerpc_clusapi_NodeNetworkControl_state);
20552 0 : if (req == NULL) {
20553 0 : return NULL;
20554 : }
20555 0 : state->out_mem_ctx = NULL;
20556 :
20557 : /* In parameters */
20558 0 : state->orig.in.hNetwork = _hNetwork;
20559 0 : state->orig.in.hNode = _hNode;
20560 0 : state->orig.in.dwControlCode = _dwControlCode;
20561 0 : state->orig.in.lpInBuffer = _lpInBuffer;
20562 0 : state->orig.in.nInBufferSize = _nInBufferSize;
20563 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
20564 :
20565 : /* Out parameters */
20566 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
20567 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
20568 0 : state->orig.out.lpcbRequired = _lpcbRequired;
20569 0 : state->orig.out.rpc_status = _rpc_status;
20570 :
20571 : /* Result */
20572 0 : NDR_ZERO_STRUCT(state->orig.out.result);
20573 :
20574 0 : state->out_mem_ctx = talloc_named_const(state, 0,
20575 : "dcerpc_clusapi_NodeNetworkControl_out_memory");
20576 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20577 0 : return tevent_req_post(req, ev);
20578 : }
20579 :
20580 : /* make a temporary copy, that we pass to the dispatch function */
20581 0 : state->tmp = state->orig;
20582 :
20583 0 : subreq = dcerpc_clusapi_NodeNetworkControl_r_send(state, ev, h, &state->tmp);
20584 0 : if (tevent_req_nomem(subreq, req)) {
20585 0 : return tevent_req_post(req, ev);
20586 : }
20587 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNetworkControl_done, req);
20588 0 : return req;
20589 : }
20590 :
20591 0 : static void dcerpc_clusapi_NodeNetworkControl_done(struct tevent_req *subreq)
20592 : {
20593 0 : struct tevent_req *req = tevent_req_callback_data(
20594 : subreq, struct tevent_req);
20595 0 : struct dcerpc_clusapi_NodeNetworkControl_state *state = tevent_req_data(
20596 : req, struct dcerpc_clusapi_NodeNetworkControl_state);
20597 : NTSTATUS status;
20598 : TALLOC_CTX *mem_ctx;
20599 :
20600 0 : if (state->out_mem_ctx) {
20601 0 : mem_ctx = state->out_mem_ctx;
20602 : } else {
20603 0 : mem_ctx = state;
20604 : }
20605 :
20606 0 : status = dcerpc_clusapi_NodeNetworkControl_r_recv(subreq, mem_ctx);
20607 0 : TALLOC_FREE(subreq);
20608 0 : if (tevent_req_nterror(req, status)) {
20609 0 : return;
20610 : }
20611 :
20612 : /* Copy out parameters */
20613 : {
20614 : size_t _copy_len_lpOutBuffer;
20615 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
20616 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
20617 0 : return;
20618 : }
20619 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
20620 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
20621 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
20622 : }
20623 : }
20624 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
20625 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
20626 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
20627 :
20628 : /* Copy result */
20629 0 : state->orig.out.result = state->tmp.out.result;
20630 :
20631 : /* Reset temporary structure */
20632 0 : NDR_ZERO_STRUCT(state->tmp);
20633 :
20634 0 : tevent_req_done(req);
20635 : }
20636 :
20637 0 : NTSTATUS dcerpc_clusapi_NodeNetworkControl_recv(struct tevent_req *req,
20638 : TALLOC_CTX *mem_ctx,
20639 : WERROR *result)
20640 : {
20641 0 : struct dcerpc_clusapi_NodeNetworkControl_state *state = tevent_req_data(
20642 : req, struct dcerpc_clusapi_NodeNetworkControl_state);
20643 : NTSTATUS status;
20644 :
20645 0 : if (tevent_req_is_nterror(req, &status)) {
20646 0 : tevent_req_received(req);
20647 0 : return status;
20648 : }
20649 :
20650 : /* Steal possible out parameters to the callers context */
20651 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20652 :
20653 : /* Return result */
20654 0 : *result = state->orig.out.result;
20655 :
20656 0 : tevent_req_received(req);
20657 0 : return NT_STATUS_OK;
20658 : }
20659 :
20660 0 : NTSTATUS dcerpc_clusapi_NodeNetworkControl(struct dcerpc_binding_handle *h,
20661 : TALLOC_CTX *mem_ctx,
20662 : struct policy_handle _hNetwork /* [in] */,
20663 : struct policy_handle _hNode /* [in] */,
20664 : uint32_t _dwControlCode /* [in] */,
20665 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
20666 : uint32_t _nInBufferSize /* [in] */,
20667 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
20668 : uint32_t _nOutBufferSize /* [in] */,
20669 : uint32_t *_lpBytesReturned /* [out] [ref] */,
20670 : uint32_t *_lpcbRequired /* [out] [ref] */,
20671 : WERROR *_rpc_status /* [out] [ref] */,
20672 : WERROR *result)
20673 : {
20674 : struct clusapi_NodeNetworkControl r;
20675 : NTSTATUS status;
20676 :
20677 : /* In parameters */
20678 0 : r.in.hNetwork = _hNetwork;
20679 0 : r.in.hNode = _hNode;
20680 0 : r.in.dwControlCode = _dwControlCode;
20681 0 : r.in.lpInBuffer = _lpInBuffer;
20682 0 : r.in.nInBufferSize = _nInBufferSize;
20683 0 : r.in.nOutBufferSize = _nOutBufferSize;
20684 :
20685 : /* Out parameters */
20686 0 : r.out.lpOutBuffer = _lpOutBuffer;
20687 0 : r.out.lpBytesReturned = _lpBytesReturned;
20688 0 : r.out.lpcbRequired = _lpcbRequired;
20689 0 : r.out.rpc_status = _rpc_status;
20690 :
20691 : /* Result */
20692 0 : NDR_ZERO_STRUCT(r.out.result);
20693 :
20694 0 : status = dcerpc_clusapi_NodeNetworkControl_r(h, mem_ctx, &r);
20695 0 : if (!NT_STATUS_IS_OK(status)) {
20696 0 : return status;
20697 : }
20698 :
20699 : /* Return variables */
20700 : {
20701 : size_t _copy_len_lpOutBuffer;
20702 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
20703 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
20704 : }
20705 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
20706 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
20707 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
20708 : }
20709 : }
20710 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
20711 0 : *_lpcbRequired = *r.out.lpcbRequired;
20712 0 : *_rpc_status = *r.out.rpc_status;
20713 :
20714 : /* Return result */
20715 0 : *result = r.out.result;
20716 :
20717 0 : return NT_STATUS_OK;
20718 : }
20719 :
20720 : struct dcerpc_clusapi_NetworkControl_r_state {
20721 : TALLOC_CTX *out_mem_ctx;
20722 : };
20723 :
20724 : static void dcerpc_clusapi_NetworkControl_r_done(struct tevent_req *subreq);
20725 :
20726 0 : struct tevent_req *dcerpc_clusapi_NetworkControl_r_send(TALLOC_CTX *mem_ctx,
20727 : struct tevent_context *ev,
20728 : struct dcerpc_binding_handle *h,
20729 : struct clusapi_NetworkControl *r)
20730 : {
20731 : struct tevent_req *req;
20732 : struct dcerpc_clusapi_NetworkControl_r_state *state;
20733 : struct tevent_req *subreq;
20734 :
20735 0 : req = tevent_req_create(mem_ctx, &state,
20736 : struct dcerpc_clusapi_NetworkControl_r_state);
20737 0 : if (req == NULL) {
20738 0 : return NULL;
20739 : }
20740 :
20741 0 : state->out_mem_ctx = talloc_new(state);
20742 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20743 0 : return tevent_req_post(req, ev);
20744 : }
20745 :
20746 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
20747 : NULL, &ndr_table_clusapi,
20748 0 : NDR_CLUSAPI_NETWORKCONTROL, state->out_mem_ctx, r);
20749 0 : if (tevent_req_nomem(subreq, req)) {
20750 0 : return tevent_req_post(req, ev);
20751 : }
20752 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NetworkControl_r_done, req);
20753 :
20754 0 : return req;
20755 : }
20756 :
20757 0 : static void dcerpc_clusapi_NetworkControl_r_done(struct tevent_req *subreq)
20758 : {
20759 0 : struct tevent_req *req =
20760 0 : tevent_req_callback_data(subreq,
20761 : struct tevent_req);
20762 : NTSTATUS status;
20763 :
20764 0 : status = dcerpc_binding_handle_call_recv(subreq);
20765 0 : TALLOC_FREE(subreq);
20766 0 : if (tevent_req_nterror(req, status)) {
20767 0 : return;
20768 : }
20769 :
20770 0 : tevent_req_done(req);
20771 : }
20772 :
20773 0 : NTSTATUS dcerpc_clusapi_NetworkControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
20774 : {
20775 0 : struct dcerpc_clusapi_NetworkControl_r_state *state =
20776 0 : tevent_req_data(req,
20777 : struct dcerpc_clusapi_NetworkControl_r_state);
20778 : NTSTATUS status;
20779 :
20780 0 : if (tevent_req_is_nterror(req, &status)) {
20781 0 : tevent_req_received(req);
20782 0 : return status;
20783 : }
20784 :
20785 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20786 :
20787 0 : tevent_req_received(req);
20788 0 : return NT_STATUS_OK;
20789 : }
20790 :
20791 0 : NTSTATUS dcerpc_clusapi_NetworkControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NetworkControl *r)
20792 : {
20793 : NTSTATUS status;
20794 :
20795 0 : status = dcerpc_binding_handle_call(h,
20796 : NULL, &ndr_table_clusapi,
20797 : NDR_CLUSAPI_NETWORKCONTROL, mem_ctx, r);
20798 :
20799 0 : return status;
20800 : }
20801 :
20802 : struct dcerpc_clusapi_NetworkControl_state {
20803 : struct clusapi_NetworkControl orig;
20804 : struct clusapi_NetworkControl tmp;
20805 : TALLOC_CTX *out_mem_ctx;
20806 : };
20807 :
20808 : static void dcerpc_clusapi_NetworkControl_done(struct tevent_req *subreq);
20809 :
20810 0 : struct tevent_req *dcerpc_clusapi_NetworkControl_send(TALLOC_CTX *mem_ctx,
20811 : struct tevent_context *ev,
20812 : struct dcerpc_binding_handle *h,
20813 : struct policy_handle _hNetwork /* [in] */,
20814 : uint32_t _dwControlCode /* [in] */,
20815 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
20816 : uint32_t _nInBufferSize /* [in] */,
20817 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
20818 : uint32_t _nOutBufferSize /* [in] */,
20819 : uint32_t *_lpBytesReturned /* [out] [ref] */,
20820 : uint32_t *_lpcbRequired /* [out] [ref] */,
20821 : WERROR *_rpc_status /* [out] [ref] */)
20822 : {
20823 : struct tevent_req *req;
20824 : struct dcerpc_clusapi_NetworkControl_state *state;
20825 : struct tevent_req *subreq;
20826 :
20827 0 : req = tevent_req_create(mem_ctx, &state,
20828 : struct dcerpc_clusapi_NetworkControl_state);
20829 0 : if (req == NULL) {
20830 0 : return NULL;
20831 : }
20832 0 : state->out_mem_ctx = NULL;
20833 :
20834 : /* In parameters */
20835 0 : state->orig.in.hNetwork = _hNetwork;
20836 0 : state->orig.in.dwControlCode = _dwControlCode;
20837 0 : state->orig.in.lpInBuffer = _lpInBuffer;
20838 0 : state->orig.in.nInBufferSize = _nInBufferSize;
20839 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
20840 :
20841 : /* Out parameters */
20842 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
20843 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
20844 0 : state->orig.out.lpcbRequired = _lpcbRequired;
20845 0 : state->orig.out.rpc_status = _rpc_status;
20846 :
20847 : /* Result */
20848 0 : NDR_ZERO_STRUCT(state->orig.out.result);
20849 :
20850 0 : state->out_mem_ctx = talloc_named_const(state, 0,
20851 : "dcerpc_clusapi_NetworkControl_out_memory");
20852 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
20853 0 : return tevent_req_post(req, ev);
20854 : }
20855 :
20856 : /* make a temporary copy, that we pass to the dispatch function */
20857 0 : state->tmp = state->orig;
20858 :
20859 0 : subreq = dcerpc_clusapi_NetworkControl_r_send(state, ev, h, &state->tmp);
20860 0 : if (tevent_req_nomem(subreq, req)) {
20861 0 : return tevent_req_post(req, ev);
20862 : }
20863 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NetworkControl_done, req);
20864 0 : return req;
20865 : }
20866 :
20867 0 : static void dcerpc_clusapi_NetworkControl_done(struct tevent_req *subreq)
20868 : {
20869 0 : struct tevent_req *req = tevent_req_callback_data(
20870 : subreq, struct tevent_req);
20871 0 : struct dcerpc_clusapi_NetworkControl_state *state = tevent_req_data(
20872 : req, struct dcerpc_clusapi_NetworkControl_state);
20873 : NTSTATUS status;
20874 : TALLOC_CTX *mem_ctx;
20875 :
20876 0 : if (state->out_mem_ctx) {
20877 0 : mem_ctx = state->out_mem_ctx;
20878 : } else {
20879 0 : mem_ctx = state;
20880 : }
20881 :
20882 0 : status = dcerpc_clusapi_NetworkControl_r_recv(subreq, mem_ctx);
20883 0 : TALLOC_FREE(subreq);
20884 0 : if (tevent_req_nterror(req, status)) {
20885 0 : return;
20886 : }
20887 :
20888 : /* Copy out parameters */
20889 : {
20890 : size_t _copy_len_lpOutBuffer;
20891 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
20892 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
20893 0 : return;
20894 : }
20895 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
20896 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
20897 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
20898 : }
20899 : }
20900 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
20901 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
20902 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
20903 :
20904 : /* Copy result */
20905 0 : state->orig.out.result = state->tmp.out.result;
20906 :
20907 : /* Reset temporary structure */
20908 0 : NDR_ZERO_STRUCT(state->tmp);
20909 :
20910 0 : tevent_req_done(req);
20911 : }
20912 :
20913 0 : NTSTATUS dcerpc_clusapi_NetworkControl_recv(struct tevent_req *req,
20914 : TALLOC_CTX *mem_ctx,
20915 : WERROR *result)
20916 : {
20917 0 : struct dcerpc_clusapi_NetworkControl_state *state = tevent_req_data(
20918 : req, struct dcerpc_clusapi_NetworkControl_state);
20919 : NTSTATUS status;
20920 :
20921 0 : if (tevent_req_is_nterror(req, &status)) {
20922 0 : tevent_req_received(req);
20923 0 : return status;
20924 : }
20925 :
20926 : /* Steal possible out parameters to the callers context */
20927 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
20928 :
20929 : /* Return result */
20930 0 : *result = state->orig.out.result;
20931 :
20932 0 : tevent_req_received(req);
20933 0 : return NT_STATUS_OK;
20934 : }
20935 :
20936 0 : NTSTATUS dcerpc_clusapi_NetworkControl(struct dcerpc_binding_handle *h,
20937 : TALLOC_CTX *mem_ctx,
20938 : struct policy_handle _hNetwork /* [in] */,
20939 : uint32_t _dwControlCode /* [in] */,
20940 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
20941 : uint32_t _nInBufferSize /* [in] */,
20942 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
20943 : uint32_t _nOutBufferSize /* [in] */,
20944 : uint32_t *_lpBytesReturned /* [out] [ref] */,
20945 : uint32_t *_lpcbRequired /* [out] [ref] */,
20946 : WERROR *_rpc_status /* [out] [ref] */,
20947 : WERROR *result)
20948 : {
20949 : struct clusapi_NetworkControl r;
20950 : NTSTATUS status;
20951 :
20952 : /* In parameters */
20953 0 : r.in.hNetwork = _hNetwork;
20954 0 : r.in.dwControlCode = _dwControlCode;
20955 0 : r.in.lpInBuffer = _lpInBuffer;
20956 0 : r.in.nInBufferSize = _nInBufferSize;
20957 0 : r.in.nOutBufferSize = _nOutBufferSize;
20958 :
20959 : /* Out parameters */
20960 0 : r.out.lpOutBuffer = _lpOutBuffer;
20961 0 : r.out.lpBytesReturned = _lpBytesReturned;
20962 0 : r.out.lpcbRequired = _lpcbRequired;
20963 0 : r.out.rpc_status = _rpc_status;
20964 :
20965 : /* Result */
20966 0 : NDR_ZERO_STRUCT(r.out.result);
20967 :
20968 0 : status = dcerpc_clusapi_NetworkControl_r(h, mem_ctx, &r);
20969 0 : if (!NT_STATUS_IS_OK(status)) {
20970 0 : return status;
20971 : }
20972 :
20973 : /* Return variables */
20974 : {
20975 : size_t _copy_len_lpOutBuffer;
20976 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
20977 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
20978 : }
20979 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
20980 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
20981 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
20982 : }
20983 : }
20984 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
20985 0 : *_lpcbRequired = *r.out.lpcbRequired;
20986 0 : *_rpc_status = *r.out.rpc_status;
20987 :
20988 : /* Return result */
20989 0 : *result = r.out.result;
20990 :
20991 0 : return NT_STATUS_OK;
20992 : }
20993 :
20994 : struct dcerpc_clusapi_AddNotifyNetwork_r_state {
20995 : TALLOC_CTX *out_mem_ctx;
20996 : };
20997 :
20998 : static void dcerpc_clusapi_AddNotifyNetwork_r_done(struct tevent_req *subreq);
20999 :
21000 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNetwork_r_send(TALLOC_CTX *mem_ctx,
21001 : struct tevent_context *ev,
21002 : struct dcerpc_binding_handle *h,
21003 : struct clusapi_AddNotifyNetwork *r)
21004 : {
21005 : struct tevent_req *req;
21006 : struct dcerpc_clusapi_AddNotifyNetwork_r_state *state;
21007 : struct tevent_req *subreq;
21008 :
21009 0 : req = tevent_req_create(mem_ctx, &state,
21010 : struct dcerpc_clusapi_AddNotifyNetwork_r_state);
21011 0 : if (req == NULL) {
21012 0 : return NULL;
21013 : }
21014 :
21015 0 : state->out_mem_ctx = talloc_new(state);
21016 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21017 0 : return tevent_req_post(req, ev);
21018 : }
21019 :
21020 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
21021 : NULL, &ndr_table_clusapi,
21022 0 : NDR_CLUSAPI_ADDNOTIFYNETWORK, state->out_mem_ctx, r);
21023 0 : if (tevent_req_nomem(subreq, req)) {
21024 0 : return tevent_req_post(req, ev);
21025 : }
21026 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNetwork_r_done, req);
21027 :
21028 0 : return req;
21029 : }
21030 :
21031 0 : static void dcerpc_clusapi_AddNotifyNetwork_r_done(struct tevent_req *subreq)
21032 : {
21033 0 : struct tevent_req *req =
21034 0 : tevent_req_callback_data(subreq,
21035 : struct tevent_req);
21036 : NTSTATUS status;
21037 :
21038 0 : status = dcerpc_binding_handle_call_recv(subreq);
21039 0 : TALLOC_FREE(subreq);
21040 0 : if (tevent_req_nterror(req, status)) {
21041 0 : return;
21042 : }
21043 :
21044 0 : tevent_req_done(req);
21045 : }
21046 :
21047 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetwork_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
21048 : {
21049 0 : struct dcerpc_clusapi_AddNotifyNetwork_r_state *state =
21050 0 : tevent_req_data(req,
21051 : struct dcerpc_clusapi_AddNotifyNetwork_r_state);
21052 : NTSTATUS status;
21053 :
21054 0 : if (tevent_req_is_nterror(req, &status)) {
21055 0 : tevent_req_received(req);
21056 0 : return status;
21057 : }
21058 :
21059 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21060 :
21061 0 : tevent_req_received(req);
21062 0 : return NT_STATUS_OK;
21063 : }
21064 :
21065 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetwork_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyNetwork *r)
21066 : {
21067 : NTSTATUS status;
21068 :
21069 0 : status = dcerpc_binding_handle_call(h,
21070 : NULL, &ndr_table_clusapi,
21071 : NDR_CLUSAPI_ADDNOTIFYNETWORK, mem_ctx, r);
21072 :
21073 0 : return status;
21074 : }
21075 :
21076 : struct dcerpc_clusapi_AddNotifyNetwork_state {
21077 : struct clusapi_AddNotifyNetwork orig;
21078 : struct clusapi_AddNotifyNetwork tmp;
21079 : TALLOC_CTX *out_mem_ctx;
21080 : };
21081 :
21082 : static void dcerpc_clusapi_AddNotifyNetwork_done(struct tevent_req *subreq);
21083 :
21084 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNetwork_send(TALLOC_CTX *mem_ctx,
21085 : struct tevent_context *ev,
21086 : struct dcerpc_binding_handle *h,
21087 : struct policy_handle _hNotify /* [in] */,
21088 : struct policy_handle _hNetwork /* [in] */,
21089 : uint32_t _dwFilter /* [in] */,
21090 : uint32_t _dwNotifyKey /* [in] */,
21091 : uint32_t *_dwStateSequence /* [out] [ref] */,
21092 : WERROR *_rpc_status /* [out] [ref] */)
21093 : {
21094 : struct tevent_req *req;
21095 : struct dcerpc_clusapi_AddNotifyNetwork_state *state;
21096 : struct tevent_req *subreq;
21097 :
21098 0 : req = tevent_req_create(mem_ctx, &state,
21099 : struct dcerpc_clusapi_AddNotifyNetwork_state);
21100 0 : if (req == NULL) {
21101 0 : return NULL;
21102 : }
21103 0 : state->out_mem_ctx = NULL;
21104 :
21105 : /* In parameters */
21106 0 : state->orig.in.hNotify = _hNotify;
21107 0 : state->orig.in.hNetwork = _hNetwork;
21108 0 : state->orig.in.dwFilter = _dwFilter;
21109 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
21110 :
21111 : /* Out parameters */
21112 0 : state->orig.out.dwStateSequence = _dwStateSequence;
21113 0 : state->orig.out.rpc_status = _rpc_status;
21114 :
21115 : /* Result */
21116 0 : NDR_ZERO_STRUCT(state->orig.out.result);
21117 :
21118 0 : state->out_mem_ctx = talloc_named_const(state, 0,
21119 : "dcerpc_clusapi_AddNotifyNetwork_out_memory");
21120 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21121 0 : return tevent_req_post(req, ev);
21122 : }
21123 :
21124 : /* make a temporary copy, that we pass to the dispatch function */
21125 0 : state->tmp = state->orig;
21126 :
21127 0 : subreq = dcerpc_clusapi_AddNotifyNetwork_r_send(state, ev, h, &state->tmp);
21128 0 : if (tevent_req_nomem(subreq, req)) {
21129 0 : return tevent_req_post(req, ev);
21130 : }
21131 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNetwork_done, req);
21132 0 : return req;
21133 : }
21134 :
21135 0 : static void dcerpc_clusapi_AddNotifyNetwork_done(struct tevent_req *subreq)
21136 : {
21137 0 : struct tevent_req *req = tevent_req_callback_data(
21138 : subreq, struct tevent_req);
21139 0 : struct dcerpc_clusapi_AddNotifyNetwork_state *state = tevent_req_data(
21140 : req, struct dcerpc_clusapi_AddNotifyNetwork_state);
21141 : NTSTATUS status;
21142 : TALLOC_CTX *mem_ctx;
21143 :
21144 0 : if (state->out_mem_ctx) {
21145 0 : mem_ctx = state->out_mem_ctx;
21146 : } else {
21147 0 : mem_ctx = state;
21148 : }
21149 :
21150 0 : status = dcerpc_clusapi_AddNotifyNetwork_r_recv(subreq, mem_ctx);
21151 0 : TALLOC_FREE(subreq);
21152 0 : if (tevent_req_nterror(req, status)) {
21153 0 : return;
21154 : }
21155 :
21156 : /* Copy out parameters */
21157 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
21158 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
21159 :
21160 : /* Copy result */
21161 0 : state->orig.out.result = state->tmp.out.result;
21162 :
21163 : /* Reset temporary structure */
21164 0 : NDR_ZERO_STRUCT(state->tmp);
21165 :
21166 0 : tevent_req_done(req);
21167 : }
21168 :
21169 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetwork_recv(struct tevent_req *req,
21170 : TALLOC_CTX *mem_ctx,
21171 : WERROR *result)
21172 : {
21173 0 : struct dcerpc_clusapi_AddNotifyNetwork_state *state = tevent_req_data(
21174 : req, struct dcerpc_clusapi_AddNotifyNetwork_state);
21175 : NTSTATUS status;
21176 :
21177 0 : if (tevent_req_is_nterror(req, &status)) {
21178 0 : tevent_req_received(req);
21179 0 : return status;
21180 : }
21181 :
21182 : /* Steal possible out parameters to the callers context */
21183 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21184 :
21185 : /* Return result */
21186 0 : *result = state->orig.out.result;
21187 :
21188 0 : tevent_req_received(req);
21189 0 : return NT_STATUS_OK;
21190 : }
21191 :
21192 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetwork(struct dcerpc_binding_handle *h,
21193 : TALLOC_CTX *mem_ctx,
21194 : struct policy_handle _hNotify /* [in] */,
21195 : struct policy_handle _hNetwork /* [in] */,
21196 : uint32_t _dwFilter /* [in] */,
21197 : uint32_t _dwNotifyKey /* [in] */,
21198 : uint32_t *_dwStateSequence /* [out] [ref] */,
21199 : WERROR *_rpc_status /* [out] [ref] */,
21200 : WERROR *result)
21201 : {
21202 : struct clusapi_AddNotifyNetwork r;
21203 : NTSTATUS status;
21204 :
21205 : /* In parameters */
21206 0 : r.in.hNotify = _hNotify;
21207 0 : r.in.hNetwork = _hNetwork;
21208 0 : r.in.dwFilter = _dwFilter;
21209 0 : r.in.dwNotifyKey = _dwNotifyKey;
21210 :
21211 : /* Out parameters */
21212 0 : r.out.dwStateSequence = _dwStateSequence;
21213 0 : r.out.rpc_status = _rpc_status;
21214 :
21215 : /* Result */
21216 0 : NDR_ZERO_STRUCT(r.out.result);
21217 :
21218 0 : status = dcerpc_clusapi_AddNotifyNetwork_r(h, mem_ctx, &r);
21219 0 : if (!NT_STATUS_IS_OK(status)) {
21220 0 : return status;
21221 : }
21222 :
21223 : /* Return variables */
21224 0 : *_dwStateSequence = *r.out.dwStateSequence;
21225 0 : *_rpc_status = *r.out.rpc_status;
21226 :
21227 : /* Return result */
21228 0 : *result = r.out.result;
21229 :
21230 0 : return NT_STATUS_OK;
21231 : }
21232 :
21233 : struct dcerpc_clusapi_ReAddNotifyNetwork_r_state {
21234 : TALLOC_CTX *out_mem_ctx;
21235 : };
21236 :
21237 : static void dcerpc_clusapi_ReAddNotifyNetwork_r_done(struct tevent_req *subreq);
21238 :
21239 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNetwork_r_send(TALLOC_CTX *mem_ctx,
21240 : struct tevent_context *ev,
21241 : struct dcerpc_binding_handle *h,
21242 : struct clusapi_ReAddNotifyNetwork *r)
21243 : {
21244 : struct tevent_req *req;
21245 : struct dcerpc_clusapi_ReAddNotifyNetwork_r_state *state;
21246 : struct tevent_req *subreq;
21247 :
21248 0 : req = tevent_req_create(mem_ctx, &state,
21249 : struct dcerpc_clusapi_ReAddNotifyNetwork_r_state);
21250 0 : if (req == NULL) {
21251 0 : return NULL;
21252 : }
21253 :
21254 0 : state->out_mem_ctx = talloc_new(state);
21255 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21256 0 : return tevent_req_post(req, ev);
21257 : }
21258 :
21259 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
21260 : NULL, &ndr_table_clusapi,
21261 0 : NDR_CLUSAPI_READDNOTIFYNETWORK, state->out_mem_ctx, r);
21262 0 : if (tevent_req_nomem(subreq, req)) {
21263 0 : return tevent_req_post(req, ev);
21264 : }
21265 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNetwork_r_done, req);
21266 :
21267 0 : return req;
21268 : }
21269 :
21270 0 : static void dcerpc_clusapi_ReAddNotifyNetwork_r_done(struct tevent_req *subreq)
21271 : {
21272 0 : struct tevent_req *req =
21273 0 : tevent_req_callback_data(subreq,
21274 : struct tevent_req);
21275 : NTSTATUS status;
21276 :
21277 0 : status = dcerpc_binding_handle_call_recv(subreq);
21278 0 : TALLOC_FREE(subreq);
21279 0 : if (tevent_req_nterror(req, status)) {
21280 0 : return;
21281 : }
21282 :
21283 0 : tevent_req_done(req);
21284 : }
21285 :
21286 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetwork_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
21287 : {
21288 0 : struct dcerpc_clusapi_ReAddNotifyNetwork_r_state *state =
21289 0 : tevent_req_data(req,
21290 : struct dcerpc_clusapi_ReAddNotifyNetwork_r_state);
21291 : NTSTATUS status;
21292 :
21293 0 : if (tevent_req_is_nterror(req, &status)) {
21294 0 : tevent_req_received(req);
21295 0 : return status;
21296 : }
21297 :
21298 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21299 :
21300 0 : tevent_req_received(req);
21301 0 : return NT_STATUS_OK;
21302 : }
21303 :
21304 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetwork_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ReAddNotifyNetwork *r)
21305 : {
21306 : NTSTATUS status;
21307 :
21308 0 : status = dcerpc_binding_handle_call(h,
21309 : NULL, &ndr_table_clusapi,
21310 : NDR_CLUSAPI_READDNOTIFYNETWORK, mem_ctx, r);
21311 :
21312 0 : return status;
21313 : }
21314 :
21315 : struct dcerpc_clusapi_ReAddNotifyNetwork_state {
21316 : struct clusapi_ReAddNotifyNetwork orig;
21317 : struct clusapi_ReAddNotifyNetwork tmp;
21318 : TALLOC_CTX *out_mem_ctx;
21319 : };
21320 :
21321 : static void dcerpc_clusapi_ReAddNotifyNetwork_done(struct tevent_req *subreq);
21322 :
21323 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNetwork_send(TALLOC_CTX *mem_ctx,
21324 : struct tevent_context *ev,
21325 : struct dcerpc_binding_handle *h,
21326 : struct policy_handle _hNotify /* [in] */,
21327 : struct policy_handle _hNetwork /* [in] */,
21328 : uint32_t _dwFilter /* [in] */,
21329 : uint32_t _dwNotifyKey /* [in] */,
21330 : uint32_t _StateSequence /* [in] */,
21331 : WERROR *_rpc_status /* [out] [ref] */)
21332 : {
21333 : struct tevent_req *req;
21334 : struct dcerpc_clusapi_ReAddNotifyNetwork_state *state;
21335 : struct tevent_req *subreq;
21336 :
21337 0 : req = tevent_req_create(mem_ctx, &state,
21338 : struct dcerpc_clusapi_ReAddNotifyNetwork_state);
21339 0 : if (req == NULL) {
21340 0 : return NULL;
21341 : }
21342 0 : state->out_mem_ctx = NULL;
21343 :
21344 : /* In parameters */
21345 0 : state->orig.in.hNotify = _hNotify;
21346 0 : state->orig.in.hNetwork = _hNetwork;
21347 0 : state->orig.in.dwFilter = _dwFilter;
21348 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
21349 0 : state->orig.in.StateSequence = _StateSequence;
21350 :
21351 : /* Out parameters */
21352 0 : state->orig.out.rpc_status = _rpc_status;
21353 :
21354 : /* Result */
21355 0 : NDR_ZERO_STRUCT(state->orig.out.result);
21356 :
21357 0 : state->out_mem_ctx = talloc_named_const(state, 0,
21358 : "dcerpc_clusapi_ReAddNotifyNetwork_out_memory");
21359 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21360 0 : return tevent_req_post(req, ev);
21361 : }
21362 :
21363 : /* make a temporary copy, that we pass to the dispatch function */
21364 0 : state->tmp = state->orig;
21365 :
21366 0 : subreq = dcerpc_clusapi_ReAddNotifyNetwork_r_send(state, ev, h, &state->tmp);
21367 0 : if (tevent_req_nomem(subreq, req)) {
21368 0 : return tevent_req_post(req, ev);
21369 : }
21370 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNetwork_done, req);
21371 0 : return req;
21372 : }
21373 :
21374 0 : static void dcerpc_clusapi_ReAddNotifyNetwork_done(struct tevent_req *subreq)
21375 : {
21376 0 : struct tevent_req *req = tevent_req_callback_data(
21377 : subreq, struct tevent_req);
21378 0 : struct dcerpc_clusapi_ReAddNotifyNetwork_state *state = tevent_req_data(
21379 : req, struct dcerpc_clusapi_ReAddNotifyNetwork_state);
21380 : NTSTATUS status;
21381 : TALLOC_CTX *mem_ctx;
21382 :
21383 0 : if (state->out_mem_ctx) {
21384 0 : mem_ctx = state->out_mem_ctx;
21385 : } else {
21386 0 : mem_ctx = state;
21387 : }
21388 :
21389 0 : status = dcerpc_clusapi_ReAddNotifyNetwork_r_recv(subreq, mem_ctx);
21390 0 : TALLOC_FREE(subreq);
21391 0 : if (tevent_req_nterror(req, status)) {
21392 0 : return;
21393 : }
21394 :
21395 : /* Copy out parameters */
21396 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
21397 :
21398 : /* Copy result */
21399 0 : state->orig.out.result = state->tmp.out.result;
21400 :
21401 : /* Reset temporary structure */
21402 0 : NDR_ZERO_STRUCT(state->tmp);
21403 :
21404 0 : tevent_req_done(req);
21405 : }
21406 :
21407 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetwork_recv(struct tevent_req *req,
21408 : TALLOC_CTX *mem_ctx,
21409 : WERROR *result)
21410 : {
21411 0 : struct dcerpc_clusapi_ReAddNotifyNetwork_state *state = tevent_req_data(
21412 : req, struct dcerpc_clusapi_ReAddNotifyNetwork_state);
21413 : NTSTATUS status;
21414 :
21415 0 : if (tevent_req_is_nterror(req, &status)) {
21416 0 : tevent_req_received(req);
21417 0 : return status;
21418 : }
21419 :
21420 : /* Steal possible out parameters to the callers context */
21421 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21422 :
21423 : /* Return result */
21424 0 : *result = state->orig.out.result;
21425 :
21426 0 : tevent_req_received(req);
21427 0 : return NT_STATUS_OK;
21428 : }
21429 :
21430 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetwork(struct dcerpc_binding_handle *h,
21431 : TALLOC_CTX *mem_ctx,
21432 : struct policy_handle _hNotify /* [in] */,
21433 : struct policy_handle _hNetwork /* [in] */,
21434 : uint32_t _dwFilter /* [in] */,
21435 : uint32_t _dwNotifyKey /* [in] */,
21436 : uint32_t _StateSequence /* [in] */,
21437 : WERROR *_rpc_status /* [out] [ref] */,
21438 : WERROR *result)
21439 : {
21440 : struct clusapi_ReAddNotifyNetwork r;
21441 : NTSTATUS status;
21442 :
21443 : /* In parameters */
21444 0 : r.in.hNotify = _hNotify;
21445 0 : r.in.hNetwork = _hNetwork;
21446 0 : r.in.dwFilter = _dwFilter;
21447 0 : r.in.dwNotifyKey = _dwNotifyKey;
21448 0 : r.in.StateSequence = _StateSequence;
21449 :
21450 : /* Out parameters */
21451 0 : r.out.rpc_status = _rpc_status;
21452 :
21453 : /* Result */
21454 0 : NDR_ZERO_STRUCT(r.out.result);
21455 :
21456 0 : status = dcerpc_clusapi_ReAddNotifyNetwork_r(h, mem_ctx, &r);
21457 0 : if (!NT_STATUS_IS_OK(status)) {
21458 0 : return status;
21459 : }
21460 :
21461 : /* Return variables */
21462 0 : *_rpc_status = *r.out.rpc_status;
21463 :
21464 : /* Return result */
21465 0 : *result = r.out.result;
21466 :
21467 0 : return NT_STATUS_OK;
21468 : }
21469 :
21470 : struct dcerpc_clusapi_OpenNetInterface_r_state {
21471 : TALLOC_CTX *out_mem_ctx;
21472 : };
21473 :
21474 : static void dcerpc_clusapi_OpenNetInterface_r_done(struct tevent_req *subreq);
21475 :
21476 0 : struct tevent_req *dcerpc_clusapi_OpenNetInterface_r_send(TALLOC_CTX *mem_ctx,
21477 : struct tevent_context *ev,
21478 : struct dcerpc_binding_handle *h,
21479 : struct clusapi_OpenNetInterface *r)
21480 : {
21481 : struct tevent_req *req;
21482 : struct dcerpc_clusapi_OpenNetInterface_r_state *state;
21483 : struct tevent_req *subreq;
21484 :
21485 0 : req = tevent_req_create(mem_ctx, &state,
21486 : struct dcerpc_clusapi_OpenNetInterface_r_state);
21487 0 : if (req == NULL) {
21488 0 : return NULL;
21489 : }
21490 :
21491 0 : state->out_mem_ctx = talloc_new(state);
21492 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21493 0 : return tevent_req_post(req, ev);
21494 : }
21495 :
21496 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
21497 : NULL, &ndr_table_clusapi,
21498 0 : NDR_CLUSAPI_OPENNETINTERFACE, state->out_mem_ctx, r);
21499 0 : if (tevent_req_nomem(subreq, req)) {
21500 0 : return tevent_req_post(req, ev);
21501 : }
21502 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetInterface_r_done, req);
21503 :
21504 0 : return req;
21505 : }
21506 :
21507 0 : static void dcerpc_clusapi_OpenNetInterface_r_done(struct tevent_req *subreq)
21508 : {
21509 0 : struct tevent_req *req =
21510 0 : tevent_req_callback_data(subreq,
21511 : struct tevent_req);
21512 : NTSTATUS status;
21513 :
21514 0 : status = dcerpc_binding_handle_call_recv(subreq);
21515 0 : TALLOC_FREE(subreq);
21516 0 : if (tevent_req_nterror(req, status)) {
21517 0 : return;
21518 : }
21519 :
21520 0 : tevent_req_done(req);
21521 : }
21522 :
21523 0 : NTSTATUS dcerpc_clusapi_OpenNetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
21524 : {
21525 0 : struct dcerpc_clusapi_OpenNetInterface_r_state *state =
21526 0 : tevent_req_data(req,
21527 : struct dcerpc_clusapi_OpenNetInterface_r_state);
21528 : NTSTATUS status;
21529 :
21530 0 : if (tevent_req_is_nterror(req, &status)) {
21531 0 : tevent_req_received(req);
21532 0 : return status;
21533 : }
21534 :
21535 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21536 :
21537 0 : tevent_req_received(req);
21538 0 : return NT_STATUS_OK;
21539 : }
21540 :
21541 0 : NTSTATUS dcerpc_clusapi_OpenNetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNetInterface *r)
21542 : {
21543 : NTSTATUS status;
21544 :
21545 0 : status = dcerpc_binding_handle_call(h,
21546 : NULL, &ndr_table_clusapi,
21547 : NDR_CLUSAPI_OPENNETINTERFACE, mem_ctx, r);
21548 :
21549 0 : return status;
21550 : }
21551 :
21552 : struct dcerpc_clusapi_OpenNetInterface_state {
21553 : struct clusapi_OpenNetInterface orig;
21554 : struct clusapi_OpenNetInterface tmp;
21555 : TALLOC_CTX *out_mem_ctx;
21556 : };
21557 :
21558 : static void dcerpc_clusapi_OpenNetInterface_done(struct tevent_req *subreq);
21559 :
21560 0 : struct tevent_req *dcerpc_clusapi_OpenNetInterface_send(TALLOC_CTX *mem_ctx,
21561 : struct tevent_context *ev,
21562 : struct dcerpc_binding_handle *h,
21563 : const char *_lpszNetInterfaceName /* [in] [charset(UTF16),ref] */,
21564 : WERROR *_Status /* [out] [ref] */,
21565 : WERROR *_rpc_status /* [out] [ref] */,
21566 : struct policy_handle *_hNetInterface /* [out] [ref] */)
21567 : {
21568 : struct tevent_req *req;
21569 : struct dcerpc_clusapi_OpenNetInterface_state *state;
21570 : struct tevent_req *subreq;
21571 :
21572 0 : req = tevent_req_create(mem_ctx, &state,
21573 : struct dcerpc_clusapi_OpenNetInterface_state);
21574 0 : if (req == NULL) {
21575 0 : return NULL;
21576 : }
21577 0 : state->out_mem_ctx = NULL;
21578 :
21579 : /* In parameters */
21580 0 : state->orig.in.lpszNetInterfaceName = _lpszNetInterfaceName;
21581 :
21582 : /* Out parameters */
21583 0 : state->orig.out.Status = _Status;
21584 0 : state->orig.out.rpc_status = _rpc_status;
21585 0 : state->orig.out.hNetInterface = _hNetInterface;
21586 :
21587 0 : state->out_mem_ctx = talloc_named_const(state, 0,
21588 : "dcerpc_clusapi_OpenNetInterface_out_memory");
21589 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21590 0 : return tevent_req_post(req, ev);
21591 : }
21592 :
21593 : /* make a temporary copy, that we pass to the dispatch function */
21594 0 : state->tmp = state->orig;
21595 :
21596 0 : subreq = dcerpc_clusapi_OpenNetInterface_r_send(state, ev, h, &state->tmp);
21597 0 : if (tevent_req_nomem(subreq, req)) {
21598 0 : return tevent_req_post(req, ev);
21599 : }
21600 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetInterface_done, req);
21601 0 : return req;
21602 : }
21603 :
21604 0 : static void dcerpc_clusapi_OpenNetInterface_done(struct tevent_req *subreq)
21605 : {
21606 0 : struct tevent_req *req = tevent_req_callback_data(
21607 : subreq, struct tevent_req);
21608 0 : struct dcerpc_clusapi_OpenNetInterface_state *state = tevent_req_data(
21609 : req, struct dcerpc_clusapi_OpenNetInterface_state);
21610 : NTSTATUS status;
21611 : TALLOC_CTX *mem_ctx;
21612 :
21613 0 : if (state->out_mem_ctx) {
21614 0 : mem_ctx = state->out_mem_ctx;
21615 : } else {
21616 0 : mem_ctx = state;
21617 : }
21618 :
21619 0 : status = dcerpc_clusapi_OpenNetInterface_r_recv(subreq, mem_ctx);
21620 0 : TALLOC_FREE(subreq);
21621 0 : if (tevent_req_nterror(req, status)) {
21622 0 : return;
21623 : }
21624 :
21625 : /* Copy out parameters */
21626 0 : *state->orig.out.Status = *state->tmp.out.Status;
21627 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
21628 0 : *state->orig.out.hNetInterface = *state->tmp.out.hNetInterface;
21629 :
21630 : /* Reset temporary structure */
21631 0 : NDR_ZERO_STRUCT(state->tmp);
21632 :
21633 0 : tevent_req_done(req);
21634 : }
21635 :
21636 0 : NTSTATUS dcerpc_clusapi_OpenNetInterface_recv(struct tevent_req *req,
21637 : TALLOC_CTX *mem_ctx)
21638 : {
21639 0 : struct dcerpc_clusapi_OpenNetInterface_state *state = tevent_req_data(
21640 : req, struct dcerpc_clusapi_OpenNetInterface_state);
21641 : NTSTATUS status;
21642 :
21643 0 : if (tevent_req_is_nterror(req, &status)) {
21644 0 : tevent_req_received(req);
21645 0 : return status;
21646 : }
21647 :
21648 : /* Steal possible out parameters to the callers context */
21649 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21650 :
21651 0 : tevent_req_received(req);
21652 0 : return NT_STATUS_OK;
21653 : }
21654 :
21655 0 : NTSTATUS dcerpc_clusapi_OpenNetInterface(struct dcerpc_binding_handle *h,
21656 : TALLOC_CTX *mem_ctx,
21657 : const char *_lpszNetInterfaceName /* [in] [charset(UTF16),ref] */,
21658 : WERROR *_Status /* [out] [ref] */,
21659 : WERROR *_rpc_status /* [out] [ref] */,
21660 : struct policy_handle *_hNetInterface /* [out] [ref] */)
21661 : {
21662 : struct clusapi_OpenNetInterface r;
21663 : NTSTATUS status;
21664 :
21665 : /* In parameters */
21666 0 : r.in.lpszNetInterfaceName = _lpszNetInterfaceName;
21667 :
21668 : /* Out parameters */
21669 0 : r.out.Status = _Status;
21670 0 : r.out.rpc_status = _rpc_status;
21671 0 : r.out.hNetInterface = _hNetInterface;
21672 :
21673 0 : status = dcerpc_clusapi_OpenNetInterface_r(h, mem_ctx, &r);
21674 0 : if (!NT_STATUS_IS_OK(status)) {
21675 0 : return status;
21676 : }
21677 :
21678 : /* Return variables */
21679 0 : *_Status = *r.out.Status;
21680 0 : *_rpc_status = *r.out.rpc_status;
21681 0 : *_hNetInterface = *r.out.hNetInterface;
21682 :
21683 : /* Return result */
21684 :
21685 0 : return NT_STATUS_OK;
21686 : }
21687 :
21688 : struct dcerpc_clusapi_CloseNetInterface_r_state {
21689 : TALLOC_CTX *out_mem_ctx;
21690 : };
21691 :
21692 : static void dcerpc_clusapi_CloseNetInterface_r_done(struct tevent_req *subreq);
21693 :
21694 0 : struct tevent_req *dcerpc_clusapi_CloseNetInterface_r_send(TALLOC_CTX *mem_ctx,
21695 : struct tevent_context *ev,
21696 : struct dcerpc_binding_handle *h,
21697 : struct clusapi_CloseNetInterface *r)
21698 : {
21699 : struct tevent_req *req;
21700 : struct dcerpc_clusapi_CloseNetInterface_r_state *state;
21701 : struct tevent_req *subreq;
21702 :
21703 0 : req = tevent_req_create(mem_ctx, &state,
21704 : struct dcerpc_clusapi_CloseNetInterface_r_state);
21705 0 : if (req == NULL) {
21706 0 : return NULL;
21707 : }
21708 :
21709 0 : state->out_mem_ctx = talloc_new(state);
21710 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21711 0 : return tevent_req_post(req, ev);
21712 : }
21713 :
21714 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
21715 : NULL, &ndr_table_clusapi,
21716 0 : NDR_CLUSAPI_CLOSENETINTERFACE, state->out_mem_ctx, r);
21717 0 : if (tevent_req_nomem(subreq, req)) {
21718 0 : return tevent_req_post(req, ev);
21719 : }
21720 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNetInterface_r_done, req);
21721 :
21722 0 : return req;
21723 : }
21724 :
21725 0 : static void dcerpc_clusapi_CloseNetInterface_r_done(struct tevent_req *subreq)
21726 : {
21727 0 : struct tevent_req *req =
21728 0 : tevent_req_callback_data(subreq,
21729 : struct tevent_req);
21730 : NTSTATUS status;
21731 :
21732 0 : status = dcerpc_binding_handle_call_recv(subreq);
21733 0 : TALLOC_FREE(subreq);
21734 0 : if (tevent_req_nterror(req, status)) {
21735 0 : return;
21736 : }
21737 :
21738 0 : tevent_req_done(req);
21739 : }
21740 :
21741 0 : NTSTATUS dcerpc_clusapi_CloseNetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
21742 : {
21743 0 : struct dcerpc_clusapi_CloseNetInterface_r_state *state =
21744 0 : tevent_req_data(req,
21745 : struct dcerpc_clusapi_CloseNetInterface_r_state);
21746 : NTSTATUS status;
21747 :
21748 0 : if (tevent_req_is_nterror(req, &status)) {
21749 0 : tevent_req_received(req);
21750 0 : return status;
21751 : }
21752 :
21753 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21754 :
21755 0 : tevent_req_received(req);
21756 0 : return NT_STATUS_OK;
21757 : }
21758 :
21759 0 : NTSTATUS dcerpc_clusapi_CloseNetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseNetInterface *r)
21760 : {
21761 : NTSTATUS status;
21762 :
21763 0 : status = dcerpc_binding_handle_call(h,
21764 : NULL, &ndr_table_clusapi,
21765 : NDR_CLUSAPI_CLOSENETINTERFACE, mem_ctx, r);
21766 :
21767 0 : return status;
21768 : }
21769 :
21770 : struct dcerpc_clusapi_CloseNetInterface_state {
21771 : struct clusapi_CloseNetInterface orig;
21772 : struct clusapi_CloseNetInterface tmp;
21773 : TALLOC_CTX *out_mem_ctx;
21774 : };
21775 :
21776 : static void dcerpc_clusapi_CloseNetInterface_done(struct tevent_req *subreq);
21777 :
21778 0 : struct tevent_req *dcerpc_clusapi_CloseNetInterface_send(TALLOC_CTX *mem_ctx,
21779 : struct tevent_context *ev,
21780 : struct dcerpc_binding_handle *h,
21781 : struct policy_handle *_NetInterface /* [in,out] [ref] */)
21782 : {
21783 : struct tevent_req *req;
21784 : struct dcerpc_clusapi_CloseNetInterface_state *state;
21785 : struct tevent_req *subreq;
21786 :
21787 0 : req = tevent_req_create(mem_ctx, &state,
21788 : struct dcerpc_clusapi_CloseNetInterface_state);
21789 0 : if (req == NULL) {
21790 0 : return NULL;
21791 : }
21792 0 : state->out_mem_ctx = NULL;
21793 :
21794 : /* In parameters */
21795 0 : state->orig.in.NetInterface = _NetInterface;
21796 :
21797 : /* Out parameters */
21798 0 : state->orig.out.NetInterface = _NetInterface;
21799 :
21800 : /* Result */
21801 0 : NDR_ZERO_STRUCT(state->orig.out.result);
21802 :
21803 0 : state->out_mem_ctx = talloc_named_const(state, 0,
21804 : "dcerpc_clusapi_CloseNetInterface_out_memory");
21805 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21806 0 : return tevent_req_post(req, ev);
21807 : }
21808 :
21809 : /* make a temporary copy, that we pass to the dispatch function */
21810 0 : state->tmp = state->orig;
21811 :
21812 0 : subreq = dcerpc_clusapi_CloseNetInterface_r_send(state, ev, h, &state->tmp);
21813 0 : if (tevent_req_nomem(subreq, req)) {
21814 0 : return tevent_req_post(req, ev);
21815 : }
21816 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseNetInterface_done, req);
21817 0 : return req;
21818 : }
21819 :
21820 0 : static void dcerpc_clusapi_CloseNetInterface_done(struct tevent_req *subreq)
21821 : {
21822 0 : struct tevent_req *req = tevent_req_callback_data(
21823 : subreq, struct tevent_req);
21824 0 : struct dcerpc_clusapi_CloseNetInterface_state *state = tevent_req_data(
21825 : req, struct dcerpc_clusapi_CloseNetInterface_state);
21826 : NTSTATUS status;
21827 : TALLOC_CTX *mem_ctx;
21828 :
21829 0 : if (state->out_mem_ctx) {
21830 0 : mem_ctx = state->out_mem_ctx;
21831 : } else {
21832 0 : mem_ctx = state;
21833 : }
21834 :
21835 0 : status = dcerpc_clusapi_CloseNetInterface_r_recv(subreq, mem_ctx);
21836 0 : TALLOC_FREE(subreq);
21837 0 : if (tevent_req_nterror(req, status)) {
21838 0 : return;
21839 : }
21840 :
21841 : /* Copy out parameters */
21842 0 : *state->orig.out.NetInterface = *state->tmp.out.NetInterface;
21843 :
21844 : /* Copy result */
21845 0 : state->orig.out.result = state->tmp.out.result;
21846 :
21847 : /* Reset temporary structure */
21848 0 : NDR_ZERO_STRUCT(state->tmp);
21849 :
21850 0 : tevent_req_done(req);
21851 : }
21852 :
21853 0 : NTSTATUS dcerpc_clusapi_CloseNetInterface_recv(struct tevent_req *req,
21854 : TALLOC_CTX *mem_ctx,
21855 : WERROR *result)
21856 : {
21857 0 : struct dcerpc_clusapi_CloseNetInterface_state *state = tevent_req_data(
21858 : req, struct dcerpc_clusapi_CloseNetInterface_state);
21859 : NTSTATUS status;
21860 :
21861 0 : if (tevent_req_is_nterror(req, &status)) {
21862 0 : tevent_req_received(req);
21863 0 : return status;
21864 : }
21865 :
21866 : /* Steal possible out parameters to the callers context */
21867 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21868 :
21869 : /* Return result */
21870 0 : *result = state->orig.out.result;
21871 :
21872 0 : tevent_req_received(req);
21873 0 : return NT_STATUS_OK;
21874 : }
21875 :
21876 0 : NTSTATUS dcerpc_clusapi_CloseNetInterface(struct dcerpc_binding_handle *h,
21877 : TALLOC_CTX *mem_ctx,
21878 : struct policy_handle *_NetInterface /* [in,out] [ref] */,
21879 : WERROR *result)
21880 : {
21881 : struct clusapi_CloseNetInterface r;
21882 : NTSTATUS status;
21883 :
21884 : /* In parameters */
21885 0 : r.in.NetInterface = _NetInterface;
21886 :
21887 : /* Out parameters */
21888 0 : r.out.NetInterface = _NetInterface;
21889 :
21890 : /* Result */
21891 0 : NDR_ZERO_STRUCT(r.out.result);
21892 :
21893 0 : status = dcerpc_clusapi_CloseNetInterface_r(h, mem_ctx, &r);
21894 0 : if (!NT_STATUS_IS_OK(status)) {
21895 0 : return status;
21896 : }
21897 :
21898 : /* Return variables */
21899 0 : *_NetInterface = *r.out.NetInterface;
21900 :
21901 : /* Return result */
21902 0 : *result = r.out.result;
21903 :
21904 0 : return NT_STATUS_OK;
21905 : }
21906 :
21907 : struct dcerpc_clusapi_GetNetInterfaceState_r_state {
21908 : TALLOC_CTX *out_mem_ctx;
21909 : };
21910 :
21911 : static void dcerpc_clusapi_GetNetInterfaceState_r_done(struct tevent_req *subreq);
21912 :
21913 0 : struct tevent_req *dcerpc_clusapi_GetNetInterfaceState_r_send(TALLOC_CTX *mem_ctx,
21914 : struct tevent_context *ev,
21915 : struct dcerpc_binding_handle *h,
21916 : struct clusapi_GetNetInterfaceState *r)
21917 : {
21918 : struct tevent_req *req;
21919 : struct dcerpc_clusapi_GetNetInterfaceState_r_state *state;
21920 : struct tevent_req *subreq;
21921 :
21922 0 : req = tevent_req_create(mem_ctx, &state,
21923 : struct dcerpc_clusapi_GetNetInterfaceState_r_state);
21924 0 : if (req == NULL) {
21925 0 : return NULL;
21926 : }
21927 :
21928 0 : state->out_mem_ctx = talloc_new(state);
21929 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
21930 0 : return tevent_req_post(req, ev);
21931 : }
21932 :
21933 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
21934 : NULL, &ndr_table_clusapi,
21935 0 : NDR_CLUSAPI_GETNETINTERFACESTATE, state->out_mem_ctx, r);
21936 0 : if (tevent_req_nomem(subreq, req)) {
21937 0 : return tevent_req_post(req, ev);
21938 : }
21939 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterfaceState_r_done, req);
21940 :
21941 0 : return req;
21942 : }
21943 :
21944 0 : static void dcerpc_clusapi_GetNetInterfaceState_r_done(struct tevent_req *subreq)
21945 : {
21946 0 : struct tevent_req *req =
21947 0 : tevent_req_callback_data(subreq,
21948 : struct tevent_req);
21949 : NTSTATUS status;
21950 :
21951 0 : status = dcerpc_binding_handle_call_recv(subreq);
21952 0 : TALLOC_FREE(subreq);
21953 0 : if (tevent_req_nterror(req, status)) {
21954 0 : return;
21955 : }
21956 :
21957 0 : tevent_req_done(req);
21958 : }
21959 :
21960 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
21961 : {
21962 0 : struct dcerpc_clusapi_GetNetInterfaceState_r_state *state =
21963 0 : tevent_req_data(req,
21964 : struct dcerpc_clusapi_GetNetInterfaceState_r_state);
21965 : NTSTATUS status;
21966 :
21967 0 : if (tevent_req_is_nterror(req, &status)) {
21968 0 : tevent_req_received(req);
21969 0 : return status;
21970 : }
21971 :
21972 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
21973 :
21974 0 : tevent_req_received(req);
21975 0 : return NT_STATUS_OK;
21976 : }
21977 :
21978 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNetInterfaceState *r)
21979 : {
21980 : NTSTATUS status;
21981 :
21982 0 : status = dcerpc_binding_handle_call(h,
21983 : NULL, &ndr_table_clusapi,
21984 : NDR_CLUSAPI_GETNETINTERFACESTATE, mem_ctx, r);
21985 :
21986 0 : return status;
21987 : }
21988 :
21989 : struct dcerpc_clusapi_GetNetInterfaceState_state {
21990 : struct clusapi_GetNetInterfaceState orig;
21991 : struct clusapi_GetNetInterfaceState tmp;
21992 : TALLOC_CTX *out_mem_ctx;
21993 : };
21994 :
21995 : static void dcerpc_clusapi_GetNetInterfaceState_done(struct tevent_req *subreq);
21996 :
21997 0 : struct tevent_req *dcerpc_clusapi_GetNetInterfaceState_send(TALLOC_CTX *mem_ctx,
21998 : struct tevent_context *ev,
21999 : struct dcerpc_binding_handle *h,
22000 : struct policy_handle _hNetInterface /* [in] */,
22001 : enum clusapi_ClusterNetInterfaceState *_State /* [out] [ref] */,
22002 : WERROR *_rpc_status /* [out] [ref] */)
22003 : {
22004 : struct tevent_req *req;
22005 : struct dcerpc_clusapi_GetNetInterfaceState_state *state;
22006 : struct tevent_req *subreq;
22007 :
22008 0 : req = tevent_req_create(mem_ctx, &state,
22009 : struct dcerpc_clusapi_GetNetInterfaceState_state);
22010 0 : if (req == NULL) {
22011 0 : return NULL;
22012 : }
22013 0 : state->out_mem_ctx = NULL;
22014 :
22015 : /* In parameters */
22016 0 : state->orig.in.hNetInterface = _hNetInterface;
22017 :
22018 : /* Out parameters */
22019 0 : state->orig.out.State = _State;
22020 0 : state->orig.out.rpc_status = _rpc_status;
22021 :
22022 : /* Result */
22023 0 : NDR_ZERO_STRUCT(state->orig.out.result);
22024 :
22025 0 : state->out_mem_ctx = talloc_named_const(state, 0,
22026 : "dcerpc_clusapi_GetNetInterfaceState_out_memory");
22027 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22028 0 : return tevent_req_post(req, ev);
22029 : }
22030 :
22031 : /* make a temporary copy, that we pass to the dispatch function */
22032 0 : state->tmp = state->orig;
22033 :
22034 0 : subreq = dcerpc_clusapi_GetNetInterfaceState_r_send(state, ev, h, &state->tmp);
22035 0 : if (tevent_req_nomem(subreq, req)) {
22036 0 : return tevent_req_post(req, ev);
22037 : }
22038 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterfaceState_done, req);
22039 0 : return req;
22040 : }
22041 :
22042 0 : static void dcerpc_clusapi_GetNetInterfaceState_done(struct tevent_req *subreq)
22043 : {
22044 0 : struct tevent_req *req = tevent_req_callback_data(
22045 : subreq, struct tevent_req);
22046 0 : struct dcerpc_clusapi_GetNetInterfaceState_state *state = tevent_req_data(
22047 : req, struct dcerpc_clusapi_GetNetInterfaceState_state);
22048 : NTSTATUS status;
22049 : TALLOC_CTX *mem_ctx;
22050 :
22051 0 : if (state->out_mem_ctx) {
22052 0 : mem_ctx = state->out_mem_ctx;
22053 : } else {
22054 0 : mem_ctx = state;
22055 : }
22056 :
22057 0 : status = dcerpc_clusapi_GetNetInterfaceState_r_recv(subreq, mem_ctx);
22058 0 : TALLOC_FREE(subreq);
22059 0 : if (tevent_req_nterror(req, status)) {
22060 0 : return;
22061 : }
22062 :
22063 : /* Copy out parameters */
22064 0 : *state->orig.out.State = *state->tmp.out.State;
22065 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
22066 :
22067 : /* Copy result */
22068 0 : state->orig.out.result = state->tmp.out.result;
22069 :
22070 : /* Reset temporary structure */
22071 0 : NDR_ZERO_STRUCT(state->tmp);
22072 :
22073 0 : tevent_req_done(req);
22074 : }
22075 :
22076 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceState_recv(struct tevent_req *req,
22077 : TALLOC_CTX *mem_ctx,
22078 : WERROR *result)
22079 : {
22080 0 : struct dcerpc_clusapi_GetNetInterfaceState_state *state = tevent_req_data(
22081 : req, struct dcerpc_clusapi_GetNetInterfaceState_state);
22082 : NTSTATUS status;
22083 :
22084 0 : if (tevent_req_is_nterror(req, &status)) {
22085 0 : tevent_req_received(req);
22086 0 : return status;
22087 : }
22088 :
22089 : /* Steal possible out parameters to the callers context */
22090 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22091 :
22092 : /* Return result */
22093 0 : *result = state->orig.out.result;
22094 :
22095 0 : tevent_req_received(req);
22096 0 : return NT_STATUS_OK;
22097 : }
22098 :
22099 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceState(struct dcerpc_binding_handle *h,
22100 : TALLOC_CTX *mem_ctx,
22101 : struct policy_handle _hNetInterface /* [in] */,
22102 : enum clusapi_ClusterNetInterfaceState *_State /* [out] [ref] */,
22103 : WERROR *_rpc_status /* [out] [ref] */,
22104 : WERROR *result)
22105 : {
22106 : struct clusapi_GetNetInterfaceState r;
22107 : NTSTATUS status;
22108 :
22109 : /* In parameters */
22110 0 : r.in.hNetInterface = _hNetInterface;
22111 :
22112 : /* Out parameters */
22113 0 : r.out.State = _State;
22114 0 : r.out.rpc_status = _rpc_status;
22115 :
22116 : /* Result */
22117 0 : NDR_ZERO_STRUCT(r.out.result);
22118 :
22119 0 : status = dcerpc_clusapi_GetNetInterfaceState_r(h, mem_ctx, &r);
22120 0 : if (!NT_STATUS_IS_OK(status)) {
22121 0 : return status;
22122 : }
22123 :
22124 : /* Return variables */
22125 0 : *_State = *r.out.State;
22126 0 : *_rpc_status = *r.out.rpc_status;
22127 :
22128 : /* Return result */
22129 0 : *result = r.out.result;
22130 :
22131 0 : return NT_STATUS_OK;
22132 : }
22133 :
22134 : struct dcerpc_clusapi_GetNetInterface_r_state {
22135 : TALLOC_CTX *out_mem_ctx;
22136 : };
22137 :
22138 : static void dcerpc_clusapi_GetNetInterface_r_done(struct tevent_req *subreq);
22139 :
22140 0 : struct tevent_req *dcerpc_clusapi_GetNetInterface_r_send(TALLOC_CTX *mem_ctx,
22141 : struct tevent_context *ev,
22142 : struct dcerpc_binding_handle *h,
22143 : struct clusapi_GetNetInterface *r)
22144 : {
22145 : struct tevent_req *req;
22146 : struct dcerpc_clusapi_GetNetInterface_r_state *state;
22147 : struct tevent_req *subreq;
22148 :
22149 0 : req = tevent_req_create(mem_ctx, &state,
22150 : struct dcerpc_clusapi_GetNetInterface_r_state);
22151 0 : if (req == NULL) {
22152 0 : return NULL;
22153 : }
22154 :
22155 0 : state->out_mem_ctx = talloc_new(state);
22156 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22157 0 : return tevent_req_post(req, ev);
22158 : }
22159 :
22160 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
22161 : NULL, &ndr_table_clusapi,
22162 0 : NDR_CLUSAPI_GETNETINTERFACE, state->out_mem_ctx, r);
22163 0 : if (tevent_req_nomem(subreq, req)) {
22164 0 : return tevent_req_post(req, ev);
22165 : }
22166 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterface_r_done, req);
22167 :
22168 0 : return req;
22169 : }
22170 :
22171 0 : static void dcerpc_clusapi_GetNetInterface_r_done(struct tevent_req *subreq)
22172 : {
22173 0 : struct tevent_req *req =
22174 0 : tevent_req_callback_data(subreq,
22175 : struct tevent_req);
22176 : NTSTATUS status;
22177 :
22178 0 : status = dcerpc_binding_handle_call_recv(subreq);
22179 0 : TALLOC_FREE(subreq);
22180 0 : if (tevent_req_nterror(req, status)) {
22181 0 : return;
22182 : }
22183 :
22184 0 : tevent_req_done(req);
22185 : }
22186 :
22187 0 : NTSTATUS dcerpc_clusapi_GetNetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
22188 : {
22189 0 : struct dcerpc_clusapi_GetNetInterface_r_state *state =
22190 0 : tevent_req_data(req,
22191 : struct dcerpc_clusapi_GetNetInterface_r_state);
22192 : NTSTATUS status;
22193 :
22194 0 : if (tevent_req_is_nterror(req, &status)) {
22195 0 : tevent_req_received(req);
22196 0 : return status;
22197 : }
22198 :
22199 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22200 :
22201 0 : tevent_req_received(req);
22202 0 : return NT_STATUS_OK;
22203 : }
22204 :
22205 0 : NTSTATUS dcerpc_clusapi_GetNetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNetInterface *r)
22206 : {
22207 : NTSTATUS status;
22208 :
22209 0 : status = dcerpc_binding_handle_call(h,
22210 : NULL, &ndr_table_clusapi,
22211 : NDR_CLUSAPI_GETNETINTERFACE, mem_ctx, r);
22212 :
22213 0 : return status;
22214 : }
22215 :
22216 : struct dcerpc_clusapi_GetNetInterface_state {
22217 : struct clusapi_GetNetInterface orig;
22218 : struct clusapi_GetNetInterface tmp;
22219 : TALLOC_CTX *out_mem_ctx;
22220 : };
22221 :
22222 : static void dcerpc_clusapi_GetNetInterface_done(struct tevent_req *subreq);
22223 :
22224 0 : struct tevent_req *dcerpc_clusapi_GetNetInterface_send(TALLOC_CTX *mem_ctx,
22225 : struct tevent_context *ev,
22226 : struct dcerpc_binding_handle *h,
22227 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
22228 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
22229 : const char **_lppszInterfaceName /* [out] [charset(UTF16),ref] */,
22230 : WERROR *_rpc_status /* [out] [ref] */)
22231 : {
22232 : struct tevent_req *req;
22233 : struct dcerpc_clusapi_GetNetInterface_state *state;
22234 : struct tevent_req *subreq;
22235 :
22236 0 : req = tevent_req_create(mem_ctx, &state,
22237 : struct dcerpc_clusapi_GetNetInterface_state);
22238 0 : if (req == NULL) {
22239 0 : return NULL;
22240 : }
22241 0 : state->out_mem_ctx = NULL;
22242 :
22243 : /* In parameters */
22244 0 : state->orig.in.lpszNodeName = _lpszNodeName;
22245 0 : state->orig.in.lpszNetworkName = _lpszNetworkName;
22246 :
22247 : /* Out parameters */
22248 0 : state->orig.out.lppszInterfaceName = _lppszInterfaceName;
22249 0 : state->orig.out.rpc_status = _rpc_status;
22250 :
22251 : /* Result */
22252 0 : NDR_ZERO_STRUCT(state->orig.out.result);
22253 :
22254 0 : state->out_mem_ctx = talloc_named_const(state, 0,
22255 : "dcerpc_clusapi_GetNetInterface_out_memory");
22256 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22257 0 : return tevent_req_post(req, ev);
22258 : }
22259 :
22260 : /* make a temporary copy, that we pass to the dispatch function */
22261 0 : state->tmp = state->orig;
22262 :
22263 0 : subreq = dcerpc_clusapi_GetNetInterface_r_send(state, ev, h, &state->tmp);
22264 0 : if (tevent_req_nomem(subreq, req)) {
22265 0 : return tevent_req_post(req, ev);
22266 : }
22267 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterface_done, req);
22268 0 : return req;
22269 : }
22270 :
22271 0 : static void dcerpc_clusapi_GetNetInterface_done(struct tevent_req *subreq)
22272 : {
22273 0 : struct tevent_req *req = tevent_req_callback_data(
22274 : subreq, struct tevent_req);
22275 0 : struct dcerpc_clusapi_GetNetInterface_state *state = tevent_req_data(
22276 : req, struct dcerpc_clusapi_GetNetInterface_state);
22277 : NTSTATUS status;
22278 : TALLOC_CTX *mem_ctx;
22279 :
22280 0 : if (state->out_mem_ctx) {
22281 0 : mem_ctx = state->out_mem_ctx;
22282 : } else {
22283 0 : mem_ctx = state;
22284 : }
22285 :
22286 0 : status = dcerpc_clusapi_GetNetInterface_r_recv(subreq, mem_ctx);
22287 0 : TALLOC_FREE(subreq);
22288 0 : if (tevent_req_nterror(req, status)) {
22289 0 : return;
22290 : }
22291 :
22292 : /* Copy out parameters */
22293 0 : *state->orig.out.lppszInterfaceName = *state->tmp.out.lppszInterfaceName;
22294 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
22295 :
22296 : /* Copy result */
22297 0 : state->orig.out.result = state->tmp.out.result;
22298 :
22299 : /* Reset temporary structure */
22300 0 : NDR_ZERO_STRUCT(state->tmp);
22301 :
22302 0 : tevent_req_done(req);
22303 : }
22304 :
22305 0 : NTSTATUS dcerpc_clusapi_GetNetInterface_recv(struct tevent_req *req,
22306 : TALLOC_CTX *mem_ctx,
22307 : WERROR *result)
22308 : {
22309 0 : struct dcerpc_clusapi_GetNetInterface_state *state = tevent_req_data(
22310 : req, struct dcerpc_clusapi_GetNetInterface_state);
22311 : NTSTATUS status;
22312 :
22313 0 : if (tevent_req_is_nterror(req, &status)) {
22314 0 : tevent_req_received(req);
22315 0 : return status;
22316 : }
22317 :
22318 : /* Steal possible out parameters to the callers context */
22319 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22320 :
22321 : /* Return result */
22322 0 : *result = state->orig.out.result;
22323 :
22324 0 : tevent_req_received(req);
22325 0 : return NT_STATUS_OK;
22326 : }
22327 :
22328 0 : NTSTATUS dcerpc_clusapi_GetNetInterface(struct dcerpc_binding_handle *h,
22329 : TALLOC_CTX *mem_ctx,
22330 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
22331 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
22332 : const char **_lppszInterfaceName /* [out] [charset(UTF16),ref] */,
22333 : WERROR *_rpc_status /* [out] [ref] */,
22334 : WERROR *result)
22335 : {
22336 : struct clusapi_GetNetInterface r;
22337 : NTSTATUS status;
22338 :
22339 : /* In parameters */
22340 0 : r.in.lpszNodeName = _lpszNodeName;
22341 0 : r.in.lpszNetworkName = _lpszNetworkName;
22342 :
22343 : /* Out parameters */
22344 0 : r.out.lppszInterfaceName = _lppszInterfaceName;
22345 0 : r.out.rpc_status = _rpc_status;
22346 :
22347 : /* Result */
22348 0 : NDR_ZERO_STRUCT(r.out.result);
22349 :
22350 0 : status = dcerpc_clusapi_GetNetInterface_r(h, mem_ctx, &r);
22351 0 : if (!NT_STATUS_IS_OK(status)) {
22352 0 : return status;
22353 : }
22354 :
22355 : /* Return variables */
22356 0 : *_lppszInterfaceName = *r.out.lppszInterfaceName;
22357 0 : *_rpc_status = *r.out.rpc_status;
22358 :
22359 : /* Return result */
22360 0 : *result = r.out.result;
22361 :
22362 0 : return NT_STATUS_OK;
22363 : }
22364 :
22365 : struct dcerpc_clusapi_GetNetInterfaceId_r_state {
22366 : TALLOC_CTX *out_mem_ctx;
22367 : };
22368 :
22369 : static void dcerpc_clusapi_GetNetInterfaceId_r_done(struct tevent_req *subreq);
22370 :
22371 0 : struct tevent_req *dcerpc_clusapi_GetNetInterfaceId_r_send(TALLOC_CTX *mem_ctx,
22372 : struct tevent_context *ev,
22373 : struct dcerpc_binding_handle *h,
22374 : struct clusapi_GetNetInterfaceId *r)
22375 : {
22376 : struct tevent_req *req;
22377 : struct dcerpc_clusapi_GetNetInterfaceId_r_state *state;
22378 : struct tevent_req *subreq;
22379 :
22380 0 : req = tevent_req_create(mem_ctx, &state,
22381 : struct dcerpc_clusapi_GetNetInterfaceId_r_state);
22382 0 : if (req == NULL) {
22383 0 : return NULL;
22384 : }
22385 :
22386 0 : state->out_mem_ctx = talloc_new(state);
22387 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22388 0 : return tevent_req_post(req, ev);
22389 : }
22390 :
22391 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
22392 : NULL, &ndr_table_clusapi,
22393 0 : NDR_CLUSAPI_GETNETINTERFACEID, state->out_mem_ctx, r);
22394 0 : if (tevent_req_nomem(subreq, req)) {
22395 0 : return tevent_req_post(req, ev);
22396 : }
22397 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterfaceId_r_done, req);
22398 :
22399 0 : return req;
22400 : }
22401 :
22402 0 : static void dcerpc_clusapi_GetNetInterfaceId_r_done(struct tevent_req *subreq)
22403 : {
22404 0 : struct tevent_req *req =
22405 0 : tevent_req_callback_data(subreq,
22406 : struct tevent_req);
22407 : NTSTATUS status;
22408 :
22409 0 : status = dcerpc_binding_handle_call_recv(subreq);
22410 0 : TALLOC_FREE(subreq);
22411 0 : if (tevent_req_nterror(req, status)) {
22412 0 : return;
22413 : }
22414 :
22415 0 : tevent_req_done(req);
22416 : }
22417 :
22418 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceId_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
22419 : {
22420 0 : struct dcerpc_clusapi_GetNetInterfaceId_r_state *state =
22421 0 : tevent_req_data(req,
22422 : struct dcerpc_clusapi_GetNetInterfaceId_r_state);
22423 : NTSTATUS status;
22424 :
22425 0 : if (tevent_req_is_nterror(req, &status)) {
22426 0 : tevent_req_received(req);
22427 0 : return status;
22428 : }
22429 :
22430 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22431 :
22432 0 : tevent_req_received(req);
22433 0 : return NT_STATUS_OK;
22434 : }
22435 :
22436 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceId_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNetInterfaceId *r)
22437 : {
22438 : NTSTATUS status;
22439 :
22440 0 : status = dcerpc_binding_handle_call(h,
22441 : NULL, &ndr_table_clusapi,
22442 : NDR_CLUSAPI_GETNETINTERFACEID, mem_ctx, r);
22443 :
22444 0 : return status;
22445 : }
22446 :
22447 : struct dcerpc_clusapi_GetNetInterfaceId_state {
22448 : struct clusapi_GetNetInterfaceId orig;
22449 : struct clusapi_GetNetInterfaceId tmp;
22450 : TALLOC_CTX *out_mem_ctx;
22451 : };
22452 :
22453 : static void dcerpc_clusapi_GetNetInterfaceId_done(struct tevent_req *subreq);
22454 :
22455 0 : struct tevent_req *dcerpc_clusapi_GetNetInterfaceId_send(TALLOC_CTX *mem_ctx,
22456 : struct tevent_context *ev,
22457 : struct dcerpc_binding_handle *h,
22458 : struct policy_handle _hNetInterface /* [in] */,
22459 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
22460 : WERROR *_rpc_status /* [out] [ref] */)
22461 : {
22462 : struct tevent_req *req;
22463 : struct dcerpc_clusapi_GetNetInterfaceId_state *state;
22464 : struct tevent_req *subreq;
22465 :
22466 0 : req = tevent_req_create(mem_ctx, &state,
22467 : struct dcerpc_clusapi_GetNetInterfaceId_state);
22468 0 : if (req == NULL) {
22469 0 : return NULL;
22470 : }
22471 0 : state->out_mem_ctx = NULL;
22472 :
22473 : /* In parameters */
22474 0 : state->orig.in.hNetInterface = _hNetInterface;
22475 :
22476 : /* Out parameters */
22477 0 : state->orig.out.pGuid = _pGuid;
22478 0 : state->orig.out.rpc_status = _rpc_status;
22479 :
22480 : /* Result */
22481 0 : NDR_ZERO_STRUCT(state->orig.out.result);
22482 :
22483 0 : state->out_mem_ctx = talloc_named_const(state, 0,
22484 : "dcerpc_clusapi_GetNetInterfaceId_out_memory");
22485 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22486 0 : return tevent_req_post(req, ev);
22487 : }
22488 :
22489 : /* make a temporary copy, that we pass to the dispatch function */
22490 0 : state->tmp = state->orig;
22491 :
22492 0 : subreq = dcerpc_clusapi_GetNetInterfaceId_r_send(state, ev, h, &state->tmp);
22493 0 : if (tevent_req_nomem(subreq, req)) {
22494 0 : return tevent_req_post(req, ev);
22495 : }
22496 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNetInterfaceId_done, req);
22497 0 : return req;
22498 : }
22499 :
22500 0 : static void dcerpc_clusapi_GetNetInterfaceId_done(struct tevent_req *subreq)
22501 : {
22502 0 : struct tevent_req *req = tevent_req_callback_data(
22503 : subreq, struct tevent_req);
22504 0 : struct dcerpc_clusapi_GetNetInterfaceId_state *state = tevent_req_data(
22505 : req, struct dcerpc_clusapi_GetNetInterfaceId_state);
22506 : NTSTATUS status;
22507 : TALLOC_CTX *mem_ctx;
22508 :
22509 0 : if (state->out_mem_ctx) {
22510 0 : mem_ctx = state->out_mem_ctx;
22511 : } else {
22512 0 : mem_ctx = state;
22513 : }
22514 :
22515 0 : status = dcerpc_clusapi_GetNetInterfaceId_r_recv(subreq, mem_ctx);
22516 0 : TALLOC_FREE(subreq);
22517 0 : if (tevent_req_nterror(req, status)) {
22518 0 : return;
22519 : }
22520 :
22521 : /* Copy out parameters */
22522 0 : *state->orig.out.pGuid = *state->tmp.out.pGuid;
22523 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
22524 :
22525 : /* Copy result */
22526 0 : state->orig.out.result = state->tmp.out.result;
22527 :
22528 : /* Reset temporary structure */
22529 0 : NDR_ZERO_STRUCT(state->tmp);
22530 :
22531 0 : tevent_req_done(req);
22532 : }
22533 :
22534 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceId_recv(struct tevent_req *req,
22535 : TALLOC_CTX *mem_ctx,
22536 : WERROR *result)
22537 : {
22538 0 : struct dcerpc_clusapi_GetNetInterfaceId_state *state = tevent_req_data(
22539 : req, struct dcerpc_clusapi_GetNetInterfaceId_state);
22540 : NTSTATUS status;
22541 :
22542 0 : if (tevent_req_is_nterror(req, &status)) {
22543 0 : tevent_req_received(req);
22544 0 : return status;
22545 : }
22546 :
22547 : /* Steal possible out parameters to the callers context */
22548 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22549 :
22550 : /* Return result */
22551 0 : *result = state->orig.out.result;
22552 :
22553 0 : tevent_req_received(req);
22554 0 : return NT_STATUS_OK;
22555 : }
22556 :
22557 0 : NTSTATUS dcerpc_clusapi_GetNetInterfaceId(struct dcerpc_binding_handle *h,
22558 : TALLOC_CTX *mem_ctx,
22559 : struct policy_handle _hNetInterface /* [in] */,
22560 : const char **_pGuid /* [out] [charset(UTF16),ref] */,
22561 : WERROR *_rpc_status /* [out] [ref] */,
22562 : WERROR *result)
22563 : {
22564 : struct clusapi_GetNetInterfaceId r;
22565 : NTSTATUS status;
22566 :
22567 : /* In parameters */
22568 0 : r.in.hNetInterface = _hNetInterface;
22569 :
22570 : /* Out parameters */
22571 0 : r.out.pGuid = _pGuid;
22572 0 : r.out.rpc_status = _rpc_status;
22573 :
22574 : /* Result */
22575 0 : NDR_ZERO_STRUCT(r.out.result);
22576 :
22577 0 : status = dcerpc_clusapi_GetNetInterfaceId_r(h, mem_ctx, &r);
22578 0 : if (!NT_STATUS_IS_OK(status)) {
22579 0 : return status;
22580 : }
22581 :
22582 : /* Return variables */
22583 0 : *_pGuid = *r.out.pGuid;
22584 0 : *_rpc_status = *r.out.rpc_status;
22585 :
22586 : /* Return result */
22587 0 : *result = r.out.result;
22588 :
22589 0 : return NT_STATUS_OK;
22590 : }
22591 :
22592 : struct dcerpc_clusapi_NodeNetInterfaceControl_r_state {
22593 : TALLOC_CTX *out_mem_ctx;
22594 : };
22595 :
22596 : static void dcerpc_clusapi_NodeNetInterfaceControl_r_done(struct tevent_req *subreq);
22597 :
22598 0 : struct tevent_req *dcerpc_clusapi_NodeNetInterfaceControl_r_send(TALLOC_CTX *mem_ctx,
22599 : struct tevent_context *ev,
22600 : struct dcerpc_binding_handle *h,
22601 : struct clusapi_NodeNetInterfaceControl *r)
22602 : {
22603 : struct tevent_req *req;
22604 : struct dcerpc_clusapi_NodeNetInterfaceControl_r_state *state;
22605 : struct tevent_req *subreq;
22606 :
22607 0 : req = tevent_req_create(mem_ctx, &state,
22608 : struct dcerpc_clusapi_NodeNetInterfaceControl_r_state);
22609 0 : if (req == NULL) {
22610 0 : return NULL;
22611 : }
22612 :
22613 0 : state->out_mem_ctx = talloc_new(state);
22614 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22615 0 : return tevent_req_post(req, ev);
22616 : }
22617 :
22618 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
22619 : NULL, &ndr_table_clusapi,
22620 0 : NDR_CLUSAPI_NODENETINTERFACECONTROL, state->out_mem_ctx, r);
22621 0 : if (tevent_req_nomem(subreq, req)) {
22622 0 : return tevent_req_post(req, ev);
22623 : }
22624 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNetInterfaceControl_r_done, req);
22625 :
22626 0 : return req;
22627 : }
22628 :
22629 0 : static void dcerpc_clusapi_NodeNetInterfaceControl_r_done(struct tevent_req *subreq)
22630 : {
22631 0 : struct tevent_req *req =
22632 0 : tevent_req_callback_data(subreq,
22633 : struct tevent_req);
22634 : NTSTATUS status;
22635 :
22636 0 : status = dcerpc_binding_handle_call_recv(subreq);
22637 0 : TALLOC_FREE(subreq);
22638 0 : if (tevent_req_nterror(req, status)) {
22639 0 : return;
22640 : }
22641 :
22642 0 : tevent_req_done(req);
22643 : }
22644 :
22645 0 : NTSTATUS dcerpc_clusapi_NodeNetInterfaceControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
22646 : {
22647 0 : struct dcerpc_clusapi_NodeNetInterfaceControl_r_state *state =
22648 0 : tevent_req_data(req,
22649 : struct dcerpc_clusapi_NodeNetInterfaceControl_r_state);
22650 : NTSTATUS status;
22651 :
22652 0 : if (tevent_req_is_nterror(req, &status)) {
22653 0 : tevent_req_received(req);
22654 0 : return status;
22655 : }
22656 :
22657 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22658 :
22659 0 : tevent_req_received(req);
22660 0 : return NT_STATUS_OK;
22661 : }
22662 :
22663 0 : NTSTATUS dcerpc_clusapi_NodeNetInterfaceControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeNetInterfaceControl *r)
22664 : {
22665 : NTSTATUS status;
22666 :
22667 0 : status = dcerpc_binding_handle_call(h,
22668 : NULL, &ndr_table_clusapi,
22669 : NDR_CLUSAPI_NODENETINTERFACECONTROL, mem_ctx, r);
22670 :
22671 0 : return status;
22672 : }
22673 :
22674 : struct dcerpc_clusapi_NodeNetInterfaceControl_state {
22675 : struct clusapi_NodeNetInterfaceControl orig;
22676 : struct clusapi_NodeNetInterfaceControl tmp;
22677 : TALLOC_CTX *out_mem_ctx;
22678 : };
22679 :
22680 : static void dcerpc_clusapi_NodeNetInterfaceControl_done(struct tevent_req *subreq);
22681 :
22682 0 : struct tevent_req *dcerpc_clusapi_NodeNetInterfaceControl_send(TALLOC_CTX *mem_ctx,
22683 : struct tevent_context *ev,
22684 : struct dcerpc_binding_handle *h,
22685 : struct policy_handle _hNetInterface /* [in] */,
22686 : struct policy_handle _hNode /* [in] */,
22687 : uint32_t _dwControlCode /* [in] */,
22688 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
22689 : uint32_t _nInBufferSize /* [in] */,
22690 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
22691 : uint32_t _nOutBufferSize /* [in] */,
22692 : uint32_t *_lpBytesReturned /* [out] [ref] */,
22693 : uint32_t *_lpcbRequired /* [out] [ref] */,
22694 : WERROR *_rpc_status /* [out] [ref] */)
22695 : {
22696 : struct tevent_req *req;
22697 : struct dcerpc_clusapi_NodeNetInterfaceControl_state *state;
22698 : struct tevent_req *subreq;
22699 :
22700 0 : req = tevent_req_create(mem_ctx, &state,
22701 : struct dcerpc_clusapi_NodeNetInterfaceControl_state);
22702 0 : if (req == NULL) {
22703 0 : return NULL;
22704 : }
22705 0 : state->out_mem_ctx = NULL;
22706 :
22707 : /* In parameters */
22708 0 : state->orig.in.hNetInterface = _hNetInterface;
22709 0 : state->orig.in.hNode = _hNode;
22710 0 : state->orig.in.dwControlCode = _dwControlCode;
22711 0 : state->orig.in.lpInBuffer = _lpInBuffer;
22712 0 : state->orig.in.nInBufferSize = _nInBufferSize;
22713 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
22714 :
22715 : /* Out parameters */
22716 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
22717 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
22718 0 : state->orig.out.lpcbRequired = _lpcbRequired;
22719 0 : state->orig.out.rpc_status = _rpc_status;
22720 :
22721 : /* Result */
22722 0 : NDR_ZERO_STRUCT(state->orig.out.result);
22723 :
22724 0 : state->out_mem_ctx = talloc_named_const(state, 0,
22725 : "dcerpc_clusapi_NodeNetInterfaceControl_out_memory");
22726 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22727 0 : return tevent_req_post(req, ev);
22728 : }
22729 :
22730 : /* make a temporary copy, that we pass to the dispatch function */
22731 0 : state->tmp = state->orig;
22732 :
22733 0 : subreq = dcerpc_clusapi_NodeNetInterfaceControl_r_send(state, ev, h, &state->tmp);
22734 0 : if (tevent_req_nomem(subreq, req)) {
22735 0 : return tevent_req_post(req, ev);
22736 : }
22737 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeNetInterfaceControl_done, req);
22738 0 : return req;
22739 : }
22740 :
22741 0 : static void dcerpc_clusapi_NodeNetInterfaceControl_done(struct tevent_req *subreq)
22742 : {
22743 0 : struct tevent_req *req = tevent_req_callback_data(
22744 : subreq, struct tevent_req);
22745 0 : struct dcerpc_clusapi_NodeNetInterfaceControl_state *state = tevent_req_data(
22746 : req, struct dcerpc_clusapi_NodeNetInterfaceControl_state);
22747 : NTSTATUS status;
22748 : TALLOC_CTX *mem_ctx;
22749 :
22750 0 : if (state->out_mem_ctx) {
22751 0 : mem_ctx = state->out_mem_ctx;
22752 : } else {
22753 0 : mem_ctx = state;
22754 : }
22755 :
22756 0 : status = dcerpc_clusapi_NodeNetInterfaceControl_r_recv(subreq, mem_ctx);
22757 0 : TALLOC_FREE(subreq);
22758 0 : if (tevent_req_nterror(req, status)) {
22759 0 : return;
22760 : }
22761 :
22762 : /* Copy out parameters */
22763 : {
22764 : size_t _copy_len_lpOutBuffer;
22765 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
22766 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
22767 0 : return;
22768 : }
22769 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
22770 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
22771 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
22772 : }
22773 : }
22774 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
22775 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
22776 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
22777 :
22778 : /* Copy result */
22779 0 : state->orig.out.result = state->tmp.out.result;
22780 :
22781 : /* Reset temporary structure */
22782 0 : NDR_ZERO_STRUCT(state->tmp);
22783 :
22784 0 : tevent_req_done(req);
22785 : }
22786 :
22787 0 : NTSTATUS dcerpc_clusapi_NodeNetInterfaceControl_recv(struct tevent_req *req,
22788 : TALLOC_CTX *mem_ctx,
22789 : WERROR *result)
22790 : {
22791 0 : struct dcerpc_clusapi_NodeNetInterfaceControl_state *state = tevent_req_data(
22792 : req, struct dcerpc_clusapi_NodeNetInterfaceControl_state);
22793 : NTSTATUS status;
22794 :
22795 0 : if (tevent_req_is_nterror(req, &status)) {
22796 0 : tevent_req_received(req);
22797 0 : return status;
22798 : }
22799 :
22800 : /* Steal possible out parameters to the callers context */
22801 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22802 :
22803 : /* Return result */
22804 0 : *result = state->orig.out.result;
22805 :
22806 0 : tevent_req_received(req);
22807 0 : return NT_STATUS_OK;
22808 : }
22809 :
22810 0 : NTSTATUS dcerpc_clusapi_NodeNetInterfaceControl(struct dcerpc_binding_handle *h,
22811 : TALLOC_CTX *mem_ctx,
22812 : struct policy_handle _hNetInterface /* [in] */,
22813 : struct policy_handle _hNode /* [in] */,
22814 : uint32_t _dwControlCode /* [in] */,
22815 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
22816 : uint32_t _nInBufferSize /* [in] */,
22817 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
22818 : uint32_t _nOutBufferSize /* [in] */,
22819 : uint32_t *_lpBytesReturned /* [out] [ref] */,
22820 : uint32_t *_lpcbRequired /* [out] [ref] */,
22821 : WERROR *_rpc_status /* [out] [ref] */,
22822 : WERROR *result)
22823 : {
22824 : struct clusapi_NodeNetInterfaceControl r;
22825 : NTSTATUS status;
22826 :
22827 : /* In parameters */
22828 0 : r.in.hNetInterface = _hNetInterface;
22829 0 : r.in.hNode = _hNode;
22830 0 : r.in.dwControlCode = _dwControlCode;
22831 0 : r.in.lpInBuffer = _lpInBuffer;
22832 0 : r.in.nInBufferSize = _nInBufferSize;
22833 0 : r.in.nOutBufferSize = _nOutBufferSize;
22834 :
22835 : /* Out parameters */
22836 0 : r.out.lpOutBuffer = _lpOutBuffer;
22837 0 : r.out.lpBytesReturned = _lpBytesReturned;
22838 0 : r.out.lpcbRequired = _lpcbRequired;
22839 0 : r.out.rpc_status = _rpc_status;
22840 :
22841 : /* Result */
22842 0 : NDR_ZERO_STRUCT(r.out.result);
22843 :
22844 0 : status = dcerpc_clusapi_NodeNetInterfaceControl_r(h, mem_ctx, &r);
22845 0 : if (!NT_STATUS_IS_OK(status)) {
22846 0 : return status;
22847 : }
22848 :
22849 : /* Return variables */
22850 : {
22851 : size_t _copy_len_lpOutBuffer;
22852 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
22853 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
22854 : }
22855 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
22856 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
22857 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
22858 : }
22859 : }
22860 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
22861 0 : *_lpcbRequired = *r.out.lpcbRequired;
22862 0 : *_rpc_status = *r.out.rpc_status;
22863 :
22864 : /* Return result */
22865 0 : *result = r.out.result;
22866 :
22867 0 : return NT_STATUS_OK;
22868 : }
22869 :
22870 : struct dcerpc_clusapi_NetInterfaceControl_r_state {
22871 : TALLOC_CTX *out_mem_ctx;
22872 : };
22873 :
22874 : static void dcerpc_clusapi_NetInterfaceControl_r_done(struct tevent_req *subreq);
22875 :
22876 0 : struct tevent_req *dcerpc_clusapi_NetInterfaceControl_r_send(TALLOC_CTX *mem_ctx,
22877 : struct tevent_context *ev,
22878 : struct dcerpc_binding_handle *h,
22879 : struct clusapi_NetInterfaceControl *r)
22880 : {
22881 : struct tevent_req *req;
22882 : struct dcerpc_clusapi_NetInterfaceControl_r_state *state;
22883 : struct tevent_req *subreq;
22884 :
22885 0 : req = tevent_req_create(mem_ctx, &state,
22886 : struct dcerpc_clusapi_NetInterfaceControl_r_state);
22887 0 : if (req == NULL) {
22888 0 : return NULL;
22889 : }
22890 :
22891 0 : state->out_mem_ctx = talloc_new(state);
22892 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
22893 0 : return tevent_req_post(req, ev);
22894 : }
22895 :
22896 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
22897 : NULL, &ndr_table_clusapi,
22898 0 : NDR_CLUSAPI_NETINTERFACECONTROL, state->out_mem_ctx, r);
22899 0 : if (tevent_req_nomem(subreq, req)) {
22900 0 : return tevent_req_post(req, ev);
22901 : }
22902 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NetInterfaceControl_r_done, req);
22903 :
22904 0 : return req;
22905 : }
22906 :
22907 0 : static void dcerpc_clusapi_NetInterfaceControl_r_done(struct tevent_req *subreq)
22908 : {
22909 0 : struct tevent_req *req =
22910 0 : tevent_req_callback_data(subreq,
22911 : struct tevent_req);
22912 : NTSTATUS status;
22913 :
22914 0 : status = dcerpc_binding_handle_call_recv(subreq);
22915 0 : TALLOC_FREE(subreq);
22916 0 : if (tevent_req_nterror(req, status)) {
22917 0 : return;
22918 : }
22919 :
22920 0 : tevent_req_done(req);
22921 : }
22922 :
22923 0 : NTSTATUS dcerpc_clusapi_NetInterfaceControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
22924 : {
22925 0 : struct dcerpc_clusapi_NetInterfaceControl_r_state *state =
22926 0 : tevent_req_data(req,
22927 : struct dcerpc_clusapi_NetInterfaceControl_r_state);
22928 : NTSTATUS status;
22929 :
22930 0 : if (tevent_req_is_nterror(req, &status)) {
22931 0 : tevent_req_received(req);
22932 0 : return status;
22933 : }
22934 :
22935 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
22936 :
22937 0 : tevent_req_received(req);
22938 0 : return NT_STATUS_OK;
22939 : }
22940 :
22941 0 : NTSTATUS dcerpc_clusapi_NetInterfaceControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NetInterfaceControl *r)
22942 : {
22943 : NTSTATUS status;
22944 :
22945 0 : status = dcerpc_binding_handle_call(h,
22946 : NULL, &ndr_table_clusapi,
22947 : NDR_CLUSAPI_NETINTERFACECONTROL, mem_ctx, r);
22948 :
22949 0 : return status;
22950 : }
22951 :
22952 : struct dcerpc_clusapi_NetInterfaceControl_state {
22953 : struct clusapi_NetInterfaceControl orig;
22954 : struct clusapi_NetInterfaceControl tmp;
22955 : TALLOC_CTX *out_mem_ctx;
22956 : };
22957 :
22958 : static void dcerpc_clusapi_NetInterfaceControl_done(struct tevent_req *subreq);
22959 :
22960 0 : struct tevent_req *dcerpc_clusapi_NetInterfaceControl_send(TALLOC_CTX *mem_ctx,
22961 : struct tevent_context *ev,
22962 : struct dcerpc_binding_handle *h,
22963 : struct policy_handle _hNetInterface /* [in] */,
22964 : uint32_t _dwControlCode /* [in] */,
22965 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
22966 : uint32_t _nInBufferSize /* [in] */,
22967 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
22968 : uint32_t _nOutBufferSize /* [in] */,
22969 : uint32_t *_lpBytesReturned /* [out] [ref] */,
22970 : uint32_t *_lpcbRequired /* [out] [ref] */,
22971 : WERROR *_rpc_status /* [out] [ref] */)
22972 : {
22973 : struct tevent_req *req;
22974 : struct dcerpc_clusapi_NetInterfaceControl_state *state;
22975 : struct tevent_req *subreq;
22976 :
22977 0 : req = tevent_req_create(mem_ctx, &state,
22978 : struct dcerpc_clusapi_NetInterfaceControl_state);
22979 0 : if (req == NULL) {
22980 0 : return NULL;
22981 : }
22982 0 : state->out_mem_ctx = NULL;
22983 :
22984 : /* In parameters */
22985 0 : state->orig.in.hNetInterface = _hNetInterface;
22986 0 : state->orig.in.dwControlCode = _dwControlCode;
22987 0 : state->orig.in.lpInBuffer = _lpInBuffer;
22988 0 : state->orig.in.nInBufferSize = _nInBufferSize;
22989 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
22990 :
22991 : /* Out parameters */
22992 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
22993 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
22994 0 : state->orig.out.lpcbRequired = _lpcbRequired;
22995 0 : state->orig.out.rpc_status = _rpc_status;
22996 :
22997 : /* Result */
22998 0 : NDR_ZERO_STRUCT(state->orig.out.result);
22999 :
23000 0 : state->out_mem_ctx = talloc_named_const(state, 0,
23001 : "dcerpc_clusapi_NetInterfaceControl_out_memory");
23002 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23003 0 : return tevent_req_post(req, ev);
23004 : }
23005 :
23006 : /* make a temporary copy, that we pass to the dispatch function */
23007 0 : state->tmp = state->orig;
23008 :
23009 0 : subreq = dcerpc_clusapi_NetInterfaceControl_r_send(state, ev, h, &state->tmp);
23010 0 : if (tevent_req_nomem(subreq, req)) {
23011 0 : return tevent_req_post(req, ev);
23012 : }
23013 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NetInterfaceControl_done, req);
23014 0 : return req;
23015 : }
23016 :
23017 0 : static void dcerpc_clusapi_NetInterfaceControl_done(struct tevent_req *subreq)
23018 : {
23019 0 : struct tevent_req *req = tevent_req_callback_data(
23020 : subreq, struct tevent_req);
23021 0 : struct dcerpc_clusapi_NetInterfaceControl_state *state = tevent_req_data(
23022 : req, struct dcerpc_clusapi_NetInterfaceControl_state);
23023 : NTSTATUS status;
23024 : TALLOC_CTX *mem_ctx;
23025 :
23026 0 : if (state->out_mem_ctx) {
23027 0 : mem_ctx = state->out_mem_ctx;
23028 : } else {
23029 0 : mem_ctx = state;
23030 : }
23031 :
23032 0 : status = dcerpc_clusapi_NetInterfaceControl_r_recv(subreq, mem_ctx);
23033 0 : TALLOC_FREE(subreq);
23034 0 : if (tevent_req_nterror(req, status)) {
23035 0 : return;
23036 : }
23037 :
23038 : /* Copy out parameters */
23039 : {
23040 : size_t _copy_len_lpOutBuffer;
23041 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
23042 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
23043 0 : return;
23044 : }
23045 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
23046 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
23047 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
23048 : }
23049 : }
23050 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
23051 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
23052 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
23053 :
23054 : /* Copy result */
23055 0 : state->orig.out.result = state->tmp.out.result;
23056 :
23057 : /* Reset temporary structure */
23058 0 : NDR_ZERO_STRUCT(state->tmp);
23059 :
23060 0 : tevent_req_done(req);
23061 : }
23062 :
23063 0 : NTSTATUS dcerpc_clusapi_NetInterfaceControl_recv(struct tevent_req *req,
23064 : TALLOC_CTX *mem_ctx,
23065 : WERROR *result)
23066 : {
23067 0 : struct dcerpc_clusapi_NetInterfaceControl_state *state = tevent_req_data(
23068 : req, struct dcerpc_clusapi_NetInterfaceControl_state);
23069 : NTSTATUS status;
23070 :
23071 0 : if (tevent_req_is_nterror(req, &status)) {
23072 0 : tevent_req_received(req);
23073 0 : return status;
23074 : }
23075 :
23076 : /* Steal possible out parameters to the callers context */
23077 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23078 :
23079 : /* Return result */
23080 0 : *result = state->orig.out.result;
23081 :
23082 0 : tevent_req_received(req);
23083 0 : return NT_STATUS_OK;
23084 : }
23085 :
23086 0 : NTSTATUS dcerpc_clusapi_NetInterfaceControl(struct dcerpc_binding_handle *h,
23087 : TALLOC_CTX *mem_ctx,
23088 : struct policy_handle _hNetInterface /* [in] */,
23089 : uint32_t _dwControlCode /* [in] */,
23090 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
23091 : uint32_t _nInBufferSize /* [in] */,
23092 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
23093 : uint32_t _nOutBufferSize /* [in] */,
23094 : uint32_t *_lpBytesReturned /* [out] [ref] */,
23095 : uint32_t *_lpcbRequired /* [out] [ref] */,
23096 : WERROR *_rpc_status /* [out] [ref] */,
23097 : WERROR *result)
23098 : {
23099 : struct clusapi_NetInterfaceControl r;
23100 : NTSTATUS status;
23101 :
23102 : /* In parameters */
23103 0 : r.in.hNetInterface = _hNetInterface;
23104 0 : r.in.dwControlCode = _dwControlCode;
23105 0 : r.in.lpInBuffer = _lpInBuffer;
23106 0 : r.in.nInBufferSize = _nInBufferSize;
23107 0 : r.in.nOutBufferSize = _nOutBufferSize;
23108 :
23109 : /* Out parameters */
23110 0 : r.out.lpOutBuffer = _lpOutBuffer;
23111 0 : r.out.lpBytesReturned = _lpBytesReturned;
23112 0 : r.out.lpcbRequired = _lpcbRequired;
23113 0 : r.out.rpc_status = _rpc_status;
23114 :
23115 : /* Result */
23116 0 : NDR_ZERO_STRUCT(r.out.result);
23117 :
23118 0 : status = dcerpc_clusapi_NetInterfaceControl_r(h, mem_ctx, &r);
23119 0 : if (!NT_STATUS_IS_OK(status)) {
23120 0 : return status;
23121 : }
23122 :
23123 : /* Return variables */
23124 : {
23125 : size_t _copy_len_lpOutBuffer;
23126 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
23127 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
23128 : }
23129 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
23130 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
23131 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
23132 : }
23133 : }
23134 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
23135 0 : *_lpcbRequired = *r.out.lpcbRequired;
23136 0 : *_rpc_status = *r.out.rpc_status;
23137 :
23138 : /* Return result */
23139 0 : *result = r.out.result;
23140 :
23141 0 : return NT_STATUS_OK;
23142 : }
23143 :
23144 : struct dcerpc_clusapi_AddNotifyNetInterface_r_state {
23145 : TALLOC_CTX *out_mem_ctx;
23146 : };
23147 :
23148 : static void dcerpc_clusapi_AddNotifyNetInterface_r_done(struct tevent_req *subreq);
23149 :
23150 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNetInterface_r_send(TALLOC_CTX *mem_ctx,
23151 : struct tevent_context *ev,
23152 : struct dcerpc_binding_handle *h,
23153 : struct clusapi_AddNotifyNetInterface *r)
23154 : {
23155 : struct tevent_req *req;
23156 : struct dcerpc_clusapi_AddNotifyNetInterface_r_state *state;
23157 : struct tevent_req *subreq;
23158 :
23159 0 : req = tevent_req_create(mem_ctx, &state,
23160 : struct dcerpc_clusapi_AddNotifyNetInterface_r_state);
23161 0 : if (req == NULL) {
23162 0 : return NULL;
23163 : }
23164 :
23165 0 : state->out_mem_ctx = talloc_new(state);
23166 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23167 0 : return tevent_req_post(req, ev);
23168 : }
23169 :
23170 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
23171 : NULL, &ndr_table_clusapi,
23172 0 : NDR_CLUSAPI_ADDNOTIFYNETINTERFACE, state->out_mem_ctx, r);
23173 0 : if (tevent_req_nomem(subreq, req)) {
23174 0 : return tevent_req_post(req, ev);
23175 : }
23176 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNetInterface_r_done, req);
23177 :
23178 0 : return req;
23179 : }
23180 :
23181 0 : static void dcerpc_clusapi_AddNotifyNetInterface_r_done(struct tevent_req *subreq)
23182 : {
23183 0 : struct tevent_req *req =
23184 0 : tevent_req_callback_data(subreq,
23185 : struct tevent_req);
23186 : NTSTATUS status;
23187 :
23188 0 : status = dcerpc_binding_handle_call_recv(subreq);
23189 0 : TALLOC_FREE(subreq);
23190 0 : if (tevent_req_nterror(req, status)) {
23191 0 : return;
23192 : }
23193 :
23194 0 : tevent_req_done(req);
23195 : }
23196 :
23197 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
23198 : {
23199 0 : struct dcerpc_clusapi_AddNotifyNetInterface_r_state *state =
23200 0 : tevent_req_data(req,
23201 : struct dcerpc_clusapi_AddNotifyNetInterface_r_state);
23202 : NTSTATUS status;
23203 :
23204 0 : if (tevent_req_is_nterror(req, &status)) {
23205 0 : tevent_req_received(req);
23206 0 : return status;
23207 : }
23208 :
23209 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23210 :
23211 0 : tevent_req_received(req);
23212 0 : return NT_STATUS_OK;
23213 : }
23214 :
23215 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyNetInterface *r)
23216 : {
23217 : NTSTATUS status;
23218 :
23219 0 : status = dcerpc_binding_handle_call(h,
23220 : NULL, &ndr_table_clusapi,
23221 : NDR_CLUSAPI_ADDNOTIFYNETINTERFACE, mem_ctx, r);
23222 :
23223 0 : return status;
23224 : }
23225 :
23226 : struct dcerpc_clusapi_AddNotifyNetInterface_state {
23227 : struct clusapi_AddNotifyNetInterface orig;
23228 : struct clusapi_AddNotifyNetInterface tmp;
23229 : TALLOC_CTX *out_mem_ctx;
23230 : };
23231 :
23232 : static void dcerpc_clusapi_AddNotifyNetInterface_done(struct tevent_req *subreq);
23233 :
23234 0 : struct tevent_req *dcerpc_clusapi_AddNotifyNetInterface_send(TALLOC_CTX *mem_ctx,
23235 : struct tevent_context *ev,
23236 : struct dcerpc_binding_handle *h,
23237 : struct policy_handle _hNotify /* [in] */,
23238 : struct policy_handle _hNetInterface /* [in] */,
23239 : uint32_t _dwFilter /* [in] */,
23240 : uint32_t _dwNotifyKey /* [in] */,
23241 : uint32_t *_dwStateSequence /* [out] [ref] */,
23242 : WERROR *_rpc_status /* [out] [ref] */)
23243 : {
23244 : struct tevent_req *req;
23245 : struct dcerpc_clusapi_AddNotifyNetInterface_state *state;
23246 : struct tevent_req *subreq;
23247 :
23248 0 : req = tevent_req_create(mem_ctx, &state,
23249 : struct dcerpc_clusapi_AddNotifyNetInterface_state);
23250 0 : if (req == NULL) {
23251 0 : return NULL;
23252 : }
23253 0 : state->out_mem_ctx = NULL;
23254 :
23255 : /* In parameters */
23256 0 : state->orig.in.hNotify = _hNotify;
23257 0 : state->orig.in.hNetInterface = _hNetInterface;
23258 0 : state->orig.in.dwFilter = _dwFilter;
23259 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
23260 :
23261 : /* Out parameters */
23262 0 : state->orig.out.dwStateSequence = _dwStateSequence;
23263 0 : state->orig.out.rpc_status = _rpc_status;
23264 :
23265 : /* Result */
23266 0 : NDR_ZERO_STRUCT(state->orig.out.result);
23267 :
23268 0 : state->out_mem_ctx = talloc_named_const(state, 0,
23269 : "dcerpc_clusapi_AddNotifyNetInterface_out_memory");
23270 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23271 0 : return tevent_req_post(req, ev);
23272 : }
23273 :
23274 : /* make a temporary copy, that we pass to the dispatch function */
23275 0 : state->tmp = state->orig;
23276 :
23277 0 : subreq = dcerpc_clusapi_AddNotifyNetInterface_r_send(state, ev, h, &state->tmp);
23278 0 : if (tevent_req_nomem(subreq, req)) {
23279 0 : return tevent_req_post(req, ev);
23280 : }
23281 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyNetInterface_done, req);
23282 0 : return req;
23283 : }
23284 :
23285 0 : static void dcerpc_clusapi_AddNotifyNetInterface_done(struct tevent_req *subreq)
23286 : {
23287 0 : struct tevent_req *req = tevent_req_callback_data(
23288 : subreq, struct tevent_req);
23289 0 : struct dcerpc_clusapi_AddNotifyNetInterface_state *state = tevent_req_data(
23290 : req, struct dcerpc_clusapi_AddNotifyNetInterface_state);
23291 : NTSTATUS status;
23292 : TALLOC_CTX *mem_ctx;
23293 :
23294 0 : if (state->out_mem_ctx) {
23295 0 : mem_ctx = state->out_mem_ctx;
23296 : } else {
23297 0 : mem_ctx = state;
23298 : }
23299 :
23300 0 : status = dcerpc_clusapi_AddNotifyNetInterface_r_recv(subreq, mem_ctx);
23301 0 : TALLOC_FREE(subreq);
23302 0 : if (tevent_req_nterror(req, status)) {
23303 0 : return;
23304 : }
23305 :
23306 : /* Copy out parameters */
23307 0 : *state->orig.out.dwStateSequence = *state->tmp.out.dwStateSequence;
23308 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
23309 :
23310 : /* Copy result */
23311 0 : state->orig.out.result = state->tmp.out.result;
23312 :
23313 : /* Reset temporary structure */
23314 0 : NDR_ZERO_STRUCT(state->tmp);
23315 :
23316 0 : tevent_req_done(req);
23317 : }
23318 :
23319 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetInterface_recv(struct tevent_req *req,
23320 : TALLOC_CTX *mem_ctx,
23321 : WERROR *result)
23322 : {
23323 0 : struct dcerpc_clusapi_AddNotifyNetInterface_state *state = tevent_req_data(
23324 : req, struct dcerpc_clusapi_AddNotifyNetInterface_state);
23325 : NTSTATUS status;
23326 :
23327 0 : if (tevent_req_is_nterror(req, &status)) {
23328 0 : tevent_req_received(req);
23329 0 : return status;
23330 : }
23331 :
23332 : /* Steal possible out parameters to the callers context */
23333 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23334 :
23335 : /* Return result */
23336 0 : *result = state->orig.out.result;
23337 :
23338 0 : tevent_req_received(req);
23339 0 : return NT_STATUS_OK;
23340 : }
23341 :
23342 0 : NTSTATUS dcerpc_clusapi_AddNotifyNetInterface(struct dcerpc_binding_handle *h,
23343 : TALLOC_CTX *mem_ctx,
23344 : struct policy_handle _hNotify /* [in] */,
23345 : struct policy_handle _hNetInterface /* [in] */,
23346 : uint32_t _dwFilter /* [in] */,
23347 : uint32_t _dwNotifyKey /* [in] */,
23348 : uint32_t *_dwStateSequence /* [out] [ref] */,
23349 : WERROR *_rpc_status /* [out] [ref] */,
23350 : WERROR *result)
23351 : {
23352 : struct clusapi_AddNotifyNetInterface r;
23353 : NTSTATUS status;
23354 :
23355 : /* In parameters */
23356 0 : r.in.hNotify = _hNotify;
23357 0 : r.in.hNetInterface = _hNetInterface;
23358 0 : r.in.dwFilter = _dwFilter;
23359 0 : r.in.dwNotifyKey = _dwNotifyKey;
23360 :
23361 : /* Out parameters */
23362 0 : r.out.dwStateSequence = _dwStateSequence;
23363 0 : r.out.rpc_status = _rpc_status;
23364 :
23365 : /* Result */
23366 0 : NDR_ZERO_STRUCT(r.out.result);
23367 :
23368 0 : status = dcerpc_clusapi_AddNotifyNetInterface_r(h, mem_ctx, &r);
23369 0 : if (!NT_STATUS_IS_OK(status)) {
23370 0 : return status;
23371 : }
23372 :
23373 : /* Return variables */
23374 0 : *_dwStateSequence = *r.out.dwStateSequence;
23375 0 : *_rpc_status = *r.out.rpc_status;
23376 :
23377 : /* Return result */
23378 0 : *result = r.out.result;
23379 :
23380 0 : return NT_STATUS_OK;
23381 : }
23382 :
23383 : struct dcerpc_clusapi_ReAddNotifyNetInterface_r_state {
23384 : TALLOC_CTX *out_mem_ctx;
23385 : };
23386 :
23387 : static void dcerpc_clusapi_ReAddNotifyNetInterface_r_done(struct tevent_req *subreq);
23388 :
23389 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNetInterface_r_send(TALLOC_CTX *mem_ctx,
23390 : struct tevent_context *ev,
23391 : struct dcerpc_binding_handle *h,
23392 : struct clusapi_ReAddNotifyNetInterface *r)
23393 : {
23394 : struct tevent_req *req;
23395 : struct dcerpc_clusapi_ReAddNotifyNetInterface_r_state *state;
23396 : struct tevent_req *subreq;
23397 :
23398 0 : req = tevent_req_create(mem_ctx, &state,
23399 : struct dcerpc_clusapi_ReAddNotifyNetInterface_r_state);
23400 0 : if (req == NULL) {
23401 0 : return NULL;
23402 : }
23403 :
23404 0 : state->out_mem_ctx = talloc_new(state);
23405 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23406 0 : return tevent_req_post(req, ev);
23407 : }
23408 :
23409 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
23410 : NULL, &ndr_table_clusapi,
23411 0 : NDR_CLUSAPI_READDNOTIFYNETINTERFACE, state->out_mem_ctx, r);
23412 0 : if (tevent_req_nomem(subreq, req)) {
23413 0 : return tevent_req_post(req, ev);
23414 : }
23415 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNetInterface_r_done, req);
23416 :
23417 0 : return req;
23418 : }
23419 :
23420 0 : static void dcerpc_clusapi_ReAddNotifyNetInterface_r_done(struct tevent_req *subreq)
23421 : {
23422 0 : struct tevent_req *req =
23423 0 : tevent_req_callback_data(subreq,
23424 : struct tevent_req);
23425 : NTSTATUS status;
23426 :
23427 0 : status = dcerpc_binding_handle_call_recv(subreq);
23428 0 : TALLOC_FREE(subreq);
23429 0 : if (tevent_req_nterror(req, status)) {
23430 0 : return;
23431 : }
23432 :
23433 0 : tevent_req_done(req);
23434 : }
23435 :
23436 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
23437 : {
23438 0 : struct dcerpc_clusapi_ReAddNotifyNetInterface_r_state *state =
23439 0 : tevent_req_data(req,
23440 : struct dcerpc_clusapi_ReAddNotifyNetInterface_r_state);
23441 : NTSTATUS status;
23442 :
23443 0 : if (tevent_req_is_nterror(req, &status)) {
23444 0 : tevent_req_received(req);
23445 0 : return status;
23446 : }
23447 :
23448 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23449 :
23450 0 : tevent_req_received(req);
23451 0 : return NT_STATUS_OK;
23452 : }
23453 :
23454 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ReAddNotifyNetInterface *r)
23455 : {
23456 : NTSTATUS status;
23457 :
23458 0 : status = dcerpc_binding_handle_call(h,
23459 : NULL, &ndr_table_clusapi,
23460 : NDR_CLUSAPI_READDNOTIFYNETINTERFACE, mem_ctx, r);
23461 :
23462 0 : return status;
23463 : }
23464 :
23465 : struct dcerpc_clusapi_ReAddNotifyNetInterface_state {
23466 : struct clusapi_ReAddNotifyNetInterface orig;
23467 : struct clusapi_ReAddNotifyNetInterface tmp;
23468 : TALLOC_CTX *out_mem_ctx;
23469 : };
23470 :
23471 : static void dcerpc_clusapi_ReAddNotifyNetInterface_done(struct tevent_req *subreq);
23472 :
23473 0 : struct tevent_req *dcerpc_clusapi_ReAddNotifyNetInterface_send(TALLOC_CTX *mem_ctx,
23474 : struct tevent_context *ev,
23475 : struct dcerpc_binding_handle *h,
23476 : struct policy_handle _hNotify /* [in] */,
23477 : struct policy_handle _hNetInterface /* [in] */,
23478 : uint32_t _dwFilter /* [in] */,
23479 : uint32_t _dwNotifyKey /* [in] */,
23480 : uint32_t _StateSequence /* [in] */,
23481 : WERROR *_rpc_status /* [out] [ref] */)
23482 : {
23483 : struct tevent_req *req;
23484 : struct dcerpc_clusapi_ReAddNotifyNetInterface_state *state;
23485 : struct tevent_req *subreq;
23486 :
23487 0 : req = tevent_req_create(mem_ctx, &state,
23488 : struct dcerpc_clusapi_ReAddNotifyNetInterface_state);
23489 0 : if (req == NULL) {
23490 0 : return NULL;
23491 : }
23492 0 : state->out_mem_ctx = NULL;
23493 :
23494 : /* In parameters */
23495 0 : state->orig.in.hNotify = _hNotify;
23496 0 : state->orig.in.hNetInterface = _hNetInterface;
23497 0 : state->orig.in.dwFilter = _dwFilter;
23498 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
23499 0 : state->orig.in.StateSequence = _StateSequence;
23500 :
23501 : /* Out parameters */
23502 0 : state->orig.out.rpc_status = _rpc_status;
23503 :
23504 : /* Result */
23505 0 : NDR_ZERO_STRUCT(state->orig.out.result);
23506 :
23507 0 : state->out_mem_ctx = talloc_named_const(state, 0,
23508 : "dcerpc_clusapi_ReAddNotifyNetInterface_out_memory");
23509 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23510 0 : return tevent_req_post(req, ev);
23511 : }
23512 :
23513 : /* make a temporary copy, that we pass to the dispatch function */
23514 0 : state->tmp = state->orig;
23515 :
23516 0 : subreq = dcerpc_clusapi_ReAddNotifyNetInterface_r_send(state, ev, h, &state->tmp);
23517 0 : if (tevent_req_nomem(subreq, req)) {
23518 0 : return tevent_req_post(req, ev);
23519 : }
23520 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ReAddNotifyNetInterface_done, req);
23521 0 : return req;
23522 : }
23523 :
23524 0 : static void dcerpc_clusapi_ReAddNotifyNetInterface_done(struct tevent_req *subreq)
23525 : {
23526 0 : struct tevent_req *req = tevent_req_callback_data(
23527 : subreq, struct tevent_req);
23528 0 : struct dcerpc_clusapi_ReAddNotifyNetInterface_state *state = tevent_req_data(
23529 : req, struct dcerpc_clusapi_ReAddNotifyNetInterface_state);
23530 : NTSTATUS status;
23531 : TALLOC_CTX *mem_ctx;
23532 :
23533 0 : if (state->out_mem_ctx) {
23534 0 : mem_ctx = state->out_mem_ctx;
23535 : } else {
23536 0 : mem_ctx = state;
23537 : }
23538 :
23539 0 : status = dcerpc_clusapi_ReAddNotifyNetInterface_r_recv(subreq, mem_ctx);
23540 0 : TALLOC_FREE(subreq);
23541 0 : if (tevent_req_nterror(req, status)) {
23542 0 : return;
23543 : }
23544 :
23545 : /* Copy out parameters */
23546 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
23547 :
23548 : /* Copy result */
23549 0 : state->orig.out.result = state->tmp.out.result;
23550 :
23551 : /* Reset temporary structure */
23552 0 : NDR_ZERO_STRUCT(state->tmp);
23553 :
23554 0 : tevent_req_done(req);
23555 : }
23556 :
23557 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetInterface_recv(struct tevent_req *req,
23558 : TALLOC_CTX *mem_ctx,
23559 : WERROR *result)
23560 : {
23561 0 : struct dcerpc_clusapi_ReAddNotifyNetInterface_state *state = tevent_req_data(
23562 : req, struct dcerpc_clusapi_ReAddNotifyNetInterface_state);
23563 : NTSTATUS status;
23564 :
23565 0 : if (tevent_req_is_nterror(req, &status)) {
23566 0 : tevent_req_received(req);
23567 0 : return status;
23568 : }
23569 :
23570 : /* Steal possible out parameters to the callers context */
23571 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23572 :
23573 : /* Return result */
23574 0 : *result = state->orig.out.result;
23575 :
23576 0 : tevent_req_received(req);
23577 0 : return NT_STATUS_OK;
23578 : }
23579 :
23580 0 : NTSTATUS dcerpc_clusapi_ReAddNotifyNetInterface(struct dcerpc_binding_handle *h,
23581 : TALLOC_CTX *mem_ctx,
23582 : struct policy_handle _hNotify /* [in] */,
23583 : struct policy_handle _hNetInterface /* [in] */,
23584 : uint32_t _dwFilter /* [in] */,
23585 : uint32_t _dwNotifyKey /* [in] */,
23586 : uint32_t _StateSequence /* [in] */,
23587 : WERROR *_rpc_status /* [out] [ref] */,
23588 : WERROR *result)
23589 : {
23590 : struct clusapi_ReAddNotifyNetInterface r;
23591 : NTSTATUS status;
23592 :
23593 : /* In parameters */
23594 0 : r.in.hNotify = _hNotify;
23595 0 : r.in.hNetInterface = _hNetInterface;
23596 0 : r.in.dwFilter = _dwFilter;
23597 0 : r.in.dwNotifyKey = _dwNotifyKey;
23598 0 : r.in.StateSequence = _StateSequence;
23599 :
23600 : /* Out parameters */
23601 0 : r.out.rpc_status = _rpc_status;
23602 :
23603 : /* Result */
23604 0 : NDR_ZERO_STRUCT(r.out.result);
23605 :
23606 0 : status = dcerpc_clusapi_ReAddNotifyNetInterface_r(h, mem_ctx, &r);
23607 0 : if (!NT_STATUS_IS_OK(status)) {
23608 0 : return status;
23609 : }
23610 :
23611 : /* Return variables */
23612 0 : *_rpc_status = *r.out.rpc_status;
23613 :
23614 : /* Return result */
23615 0 : *result = r.out.result;
23616 :
23617 0 : return NT_STATUS_OK;
23618 : }
23619 :
23620 : struct dcerpc_clusapi_CreateNodeEnum_r_state {
23621 : TALLOC_CTX *out_mem_ctx;
23622 : };
23623 :
23624 : static void dcerpc_clusapi_CreateNodeEnum_r_done(struct tevent_req *subreq);
23625 :
23626 0 : struct tevent_req *dcerpc_clusapi_CreateNodeEnum_r_send(TALLOC_CTX *mem_ctx,
23627 : struct tevent_context *ev,
23628 : struct dcerpc_binding_handle *h,
23629 : struct clusapi_CreateNodeEnum *r)
23630 : {
23631 : struct tevent_req *req;
23632 : struct dcerpc_clusapi_CreateNodeEnum_r_state *state;
23633 : struct tevent_req *subreq;
23634 :
23635 0 : req = tevent_req_create(mem_ctx, &state,
23636 : struct dcerpc_clusapi_CreateNodeEnum_r_state);
23637 0 : if (req == NULL) {
23638 0 : return NULL;
23639 : }
23640 :
23641 0 : state->out_mem_ctx = talloc_new(state);
23642 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23643 0 : return tevent_req_post(req, ev);
23644 : }
23645 :
23646 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
23647 : NULL, &ndr_table_clusapi,
23648 0 : NDR_CLUSAPI_CREATENODEENUM, state->out_mem_ctx, r);
23649 0 : if (tevent_req_nomem(subreq, req)) {
23650 0 : return tevent_req_post(req, ev);
23651 : }
23652 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNodeEnum_r_done, req);
23653 :
23654 0 : return req;
23655 : }
23656 :
23657 0 : static void dcerpc_clusapi_CreateNodeEnum_r_done(struct tevent_req *subreq)
23658 : {
23659 0 : struct tevent_req *req =
23660 0 : tevent_req_callback_data(subreq,
23661 : struct tevent_req);
23662 : NTSTATUS status;
23663 :
23664 0 : status = dcerpc_binding_handle_call_recv(subreq);
23665 0 : TALLOC_FREE(subreq);
23666 0 : if (tevent_req_nterror(req, status)) {
23667 0 : return;
23668 : }
23669 :
23670 0 : tevent_req_done(req);
23671 : }
23672 :
23673 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
23674 : {
23675 0 : struct dcerpc_clusapi_CreateNodeEnum_r_state *state =
23676 0 : tevent_req_data(req,
23677 : struct dcerpc_clusapi_CreateNodeEnum_r_state);
23678 : NTSTATUS status;
23679 :
23680 0 : if (tevent_req_is_nterror(req, &status)) {
23681 0 : tevent_req_received(req);
23682 0 : return status;
23683 : }
23684 :
23685 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23686 :
23687 0 : tevent_req_received(req);
23688 0 : return NT_STATUS_OK;
23689 : }
23690 :
23691 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNodeEnum *r)
23692 : {
23693 : NTSTATUS status;
23694 :
23695 0 : status = dcerpc_binding_handle_call(h,
23696 : NULL, &ndr_table_clusapi,
23697 : NDR_CLUSAPI_CREATENODEENUM, mem_ctx, r);
23698 :
23699 0 : return status;
23700 : }
23701 :
23702 : struct dcerpc_clusapi_CreateNodeEnum_state {
23703 : struct clusapi_CreateNodeEnum orig;
23704 : struct clusapi_CreateNodeEnum tmp;
23705 : TALLOC_CTX *out_mem_ctx;
23706 : };
23707 :
23708 : static void dcerpc_clusapi_CreateNodeEnum_done(struct tevent_req *subreq);
23709 :
23710 0 : struct tevent_req *dcerpc_clusapi_CreateNodeEnum_send(TALLOC_CTX *mem_ctx,
23711 : struct tevent_context *ev,
23712 : struct dcerpc_binding_handle *h,
23713 : struct policy_handle _hNode /* [in] */,
23714 : uint32_t _dwType /* [in] */,
23715 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
23716 : WERROR *_rpc_status /* [out] [ref] */)
23717 : {
23718 : struct tevent_req *req;
23719 : struct dcerpc_clusapi_CreateNodeEnum_state *state;
23720 : struct tevent_req *subreq;
23721 :
23722 0 : req = tevent_req_create(mem_ctx, &state,
23723 : struct dcerpc_clusapi_CreateNodeEnum_state);
23724 0 : if (req == NULL) {
23725 0 : return NULL;
23726 : }
23727 0 : state->out_mem_ctx = NULL;
23728 :
23729 : /* In parameters */
23730 0 : state->orig.in.hNode = _hNode;
23731 0 : state->orig.in.dwType = _dwType;
23732 :
23733 : /* Out parameters */
23734 0 : state->orig.out.ReturnEnum = _ReturnEnum;
23735 0 : state->orig.out.rpc_status = _rpc_status;
23736 :
23737 : /* Result */
23738 0 : NDR_ZERO_STRUCT(state->orig.out.result);
23739 :
23740 0 : state->out_mem_ctx = talloc_named_const(state, 0,
23741 : "dcerpc_clusapi_CreateNodeEnum_out_memory");
23742 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23743 0 : return tevent_req_post(req, ev);
23744 : }
23745 :
23746 : /* make a temporary copy, that we pass to the dispatch function */
23747 0 : state->tmp = state->orig;
23748 :
23749 0 : subreq = dcerpc_clusapi_CreateNodeEnum_r_send(state, ev, h, &state->tmp);
23750 0 : if (tevent_req_nomem(subreq, req)) {
23751 0 : return tevent_req_post(req, ev);
23752 : }
23753 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNodeEnum_done, req);
23754 0 : return req;
23755 : }
23756 :
23757 0 : static void dcerpc_clusapi_CreateNodeEnum_done(struct tevent_req *subreq)
23758 : {
23759 0 : struct tevent_req *req = tevent_req_callback_data(
23760 : subreq, struct tevent_req);
23761 0 : struct dcerpc_clusapi_CreateNodeEnum_state *state = tevent_req_data(
23762 : req, struct dcerpc_clusapi_CreateNodeEnum_state);
23763 : NTSTATUS status;
23764 : TALLOC_CTX *mem_ctx;
23765 :
23766 0 : if (state->out_mem_ctx) {
23767 0 : mem_ctx = state->out_mem_ctx;
23768 : } else {
23769 0 : mem_ctx = state;
23770 : }
23771 :
23772 0 : status = dcerpc_clusapi_CreateNodeEnum_r_recv(subreq, mem_ctx);
23773 0 : TALLOC_FREE(subreq);
23774 0 : if (tevent_req_nterror(req, status)) {
23775 0 : return;
23776 : }
23777 :
23778 : /* Copy out parameters */
23779 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
23780 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
23781 :
23782 : /* Copy result */
23783 0 : state->orig.out.result = state->tmp.out.result;
23784 :
23785 : /* Reset temporary structure */
23786 0 : NDR_ZERO_STRUCT(state->tmp);
23787 :
23788 0 : tevent_req_done(req);
23789 : }
23790 :
23791 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnum_recv(struct tevent_req *req,
23792 : TALLOC_CTX *mem_ctx,
23793 : WERROR *result)
23794 : {
23795 0 : struct dcerpc_clusapi_CreateNodeEnum_state *state = tevent_req_data(
23796 : req, struct dcerpc_clusapi_CreateNodeEnum_state);
23797 : NTSTATUS status;
23798 :
23799 0 : if (tevent_req_is_nterror(req, &status)) {
23800 0 : tevent_req_received(req);
23801 0 : return status;
23802 : }
23803 :
23804 : /* Steal possible out parameters to the callers context */
23805 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23806 :
23807 : /* Return result */
23808 0 : *result = state->orig.out.result;
23809 :
23810 0 : tevent_req_received(req);
23811 0 : return NT_STATUS_OK;
23812 : }
23813 :
23814 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnum(struct dcerpc_binding_handle *h,
23815 : TALLOC_CTX *mem_ctx,
23816 : struct policy_handle _hNode /* [in] */,
23817 : uint32_t _dwType /* [in] */,
23818 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
23819 : WERROR *_rpc_status /* [out] [ref] */,
23820 : WERROR *result)
23821 : {
23822 : struct clusapi_CreateNodeEnum r;
23823 : NTSTATUS status;
23824 :
23825 : /* In parameters */
23826 0 : r.in.hNode = _hNode;
23827 0 : r.in.dwType = _dwType;
23828 :
23829 : /* Out parameters */
23830 0 : r.out.ReturnEnum = _ReturnEnum;
23831 0 : r.out.rpc_status = _rpc_status;
23832 :
23833 : /* Result */
23834 0 : NDR_ZERO_STRUCT(r.out.result);
23835 :
23836 0 : status = dcerpc_clusapi_CreateNodeEnum_r(h, mem_ctx, &r);
23837 0 : if (!NT_STATUS_IS_OK(status)) {
23838 0 : return status;
23839 : }
23840 :
23841 : /* Return variables */
23842 0 : *_ReturnEnum = *r.out.ReturnEnum;
23843 0 : *_rpc_status = *r.out.rpc_status;
23844 :
23845 : /* Return result */
23846 0 : *result = r.out.result;
23847 :
23848 0 : return NT_STATUS_OK;
23849 : }
23850 :
23851 : struct dcerpc_clusapi_GetClusterVersion2_r_state {
23852 : TALLOC_CTX *out_mem_ctx;
23853 : };
23854 :
23855 : static void dcerpc_clusapi_GetClusterVersion2_r_done(struct tevent_req *subreq);
23856 :
23857 0 : struct tevent_req *dcerpc_clusapi_GetClusterVersion2_r_send(TALLOC_CTX *mem_ctx,
23858 : struct tevent_context *ev,
23859 : struct dcerpc_binding_handle *h,
23860 : struct clusapi_GetClusterVersion2 *r)
23861 : {
23862 : struct tevent_req *req;
23863 : struct dcerpc_clusapi_GetClusterVersion2_r_state *state;
23864 : struct tevent_req *subreq;
23865 :
23866 0 : req = tevent_req_create(mem_ctx, &state,
23867 : struct dcerpc_clusapi_GetClusterVersion2_r_state);
23868 0 : if (req == NULL) {
23869 0 : return NULL;
23870 : }
23871 :
23872 0 : state->out_mem_ctx = talloc_new(state);
23873 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23874 0 : return tevent_req_post(req, ev);
23875 : }
23876 :
23877 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
23878 : NULL, &ndr_table_clusapi,
23879 0 : NDR_CLUSAPI_GETCLUSTERVERSION2, state->out_mem_ctx, r);
23880 0 : if (tevent_req_nomem(subreq, req)) {
23881 0 : return tevent_req_post(req, ev);
23882 : }
23883 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterVersion2_r_done, req);
23884 :
23885 0 : return req;
23886 : }
23887 :
23888 0 : static void dcerpc_clusapi_GetClusterVersion2_r_done(struct tevent_req *subreq)
23889 : {
23890 0 : struct tevent_req *req =
23891 0 : tevent_req_callback_data(subreq,
23892 : struct tevent_req);
23893 : NTSTATUS status;
23894 :
23895 0 : status = dcerpc_binding_handle_call_recv(subreq);
23896 0 : TALLOC_FREE(subreq);
23897 0 : if (tevent_req_nterror(req, status)) {
23898 0 : return;
23899 : }
23900 :
23901 0 : tevent_req_done(req);
23902 : }
23903 :
23904 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
23905 : {
23906 0 : struct dcerpc_clusapi_GetClusterVersion2_r_state *state =
23907 0 : tevent_req_data(req,
23908 : struct dcerpc_clusapi_GetClusterVersion2_r_state);
23909 : NTSTATUS status;
23910 :
23911 0 : if (tevent_req_is_nterror(req, &status)) {
23912 0 : tevent_req_received(req);
23913 0 : return status;
23914 : }
23915 :
23916 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
23917 :
23918 0 : tevent_req_received(req);
23919 0 : return NT_STATUS_OK;
23920 : }
23921 :
23922 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetClusterVersion2 *r)
23923 : {
23924 : NTSTATUS status;
23925 :
23926 0 : status = dcerpc_binding_handle_call(h,
23927 : NULL, &ndr_table_clusapi,
23928 : NDR_CLUSAPI_GETCLUSTERVERSION2, mem_ctx, r);
23929 :
23930 0 : return status;
23931 : }
23932 :
23933 : struct dcerpc_clusapi_GetClusterVersion2_state {
23934 : struct clusapi_GetClusterVersion2 orig;
23935 : struct clusapi_GetClusterVersion2 tmp;
23936 : TALLOC_CTX *out_mem_ctx;
23937 : };
23938 :
23939 : static void dcerpc_clusapi_GetClusterVersion2_done(struct tevent_req *subreq);
23940 :
23941 0 : struct tevent_req *dcerpc_clusapi_GetClusterVersion2_send(TALLOC_CTX *mem_ctx,
23942 : struct tevent_context *ev,
23943 : struct dcerpc_binding_handle *h,
23944 : uint16_t *_lpwMajorVersion /* [out] [ref] */,
23945 : uint16_t *_lpwMinorVersion /* [out] [ref] */,
23946 : uint16_t *_lpwBuildNumber /* [out] [ref] */,
23947 : const char **_lpszVendorId /* [out] [charset(UTF16),ref] */,
23948 : const char **_lpszCSDVersion /* [out] [charset(UTF16),ref] */,
23949 : struct CLUSTER_OPERATIONAL_VERSION_INFO **_ppClusterOpVerInfo /* [out] [ref] */,
23950 : WERROR *_rpc_status /* [out] [ref] */)
23951 : {
23952 : struct tevent_req *req;
23953 : struct dcerpc_clusapi_GetClusterVersion2_state *state;
23954 : struct tevent_req *subreq;
23955 :
23956 0 : req = tevent_req_create(mem_ctx, &state,
23957 : struct dcerpc_clusapi_GetClusterVersion2_state);
23958 0 : if (req == NULL) {
23959 0 : return NULL;
23960 : }
23961 0 : state->out_mem_ctx = NULL;
23962 :
23963 : /* In parameters */
23964 :
23965 : /* Out parameters */
23966 0 : state->orig.out.lpwMajorVersion = _lpwMajorVersion;
23967 0 : state->orig.out.lpwMinorVersion = _lpwMinorVersion;
23968 0 : state->orig.out.lpwBuildNumber = _lpwBuildNumber;
23969 0 : state->orig.out.lpszVendorId = _lpszVendorId;
23970 0 : state->orig.out.lpszCSDVersion = _lpszCSDVersion;
23971 0 : state->orig.out.ppClusterOpVerInfo = _ppClusterOpVerInfo;
23972 0 : state->orig.out.rpc_status = _rpc_status;
23973 :
23974 : /* Result */
23975 0 : NDR_ZERO_STRUCT(state->orig.out.result);
23976 :
23977 0 : state->out_mem_ctx = talloc_named_const(state, 0,
23978 : "dcerpc_clusapi_GetClusterVersion2_out_memory");
23979 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
23980 0 : return tevent_req_post(req, ev);
23981 : }
23982 :
23983 : /* make a temporary copy, that we pass to the dispatch function */
23984 0 : state->tmp = state->orig;
23985 :
23986 0 : subreq = dcerpc_clusapi_GetClusterVersion2_r_send(state, ev, h, &state->tmp);
23987 0 : if (tevent_req_nomem(subreq, req)) {
23988 0 : return tevent_req_post(req, ev);
23989 : }
23990 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetClusterVersion2_done, req);
23991 0 : return req;
23992 : }
23993 :
23994 0 : static void dcerpc_clusapi_GetClusterVersion2_done(struct tevent_req *subreq)
23995 : {
23996 0 : struct tevent_req *req = tevent_req_callback_data(
23997 : subreq, struct tevent_req);
23998 0 : struct dcerpc_clusapi_GetClusterVersion2_state *state = tevent_req_data(
23999 : req, struct dcerpc_clusapi_GetClusterVersion2_state);
24000 : NTSTATUS status;
24001 : TALLOC_CTX *mem_ctx;
24002 :
24003 0 : if (state->out_mem_ctx) {
24004 0 : mem_ctx = state->out_mem_ctx;
24005 : } else {
24006 0 : mem_ctx = state;
24007 : }
24008 :
24009 0 : status = dcerpc_clusapi_GetClusterVersion2_r_recv(subreq, mem_ctx);
24010 0 : TALLOC_FREE(subreq);
24011 0 : if (tevent_req_nterror(req, status)) {
24012 0 : return;
24013 : }
24014 :
24015 : /* Copy out parameters */
24016 0 : *state->orig.out.lpwMajorVersion = *state->tmp.out.lpwMajorVersion;
24017 0 : *state->orig.out.lpwMinorVersion = *state->tmp.out.lpwMinorVersion;
24018 0 : *state->orig.out.lpwBuildNumber = *state->tmp.out.lpwBuildNumber;
24019 0 : *state->orig.out.lpszVendorId = *state->tmp.out.lpszVendorId;
24020 0 : *state->orig.out.lpszCSDVersion = *state->tmp.out.lpszCSDVersion;
24021 0 : *state->orig.out.ppClusterOpVerInfo = *state->tmp.out.ppClusterOpVerInfo;
24022 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
24023 :
24024 : /* Copy result */
24025 0 : state->orig.out.result = state->tmp.out.result;
24026 :
24027 : /* Reset temporary structure */
24028 0 : NDR_ZERO_STRUCT(state->tmp);
24029 :
24030 0 : tevent_req_done(req);
24031 : }
24032 :
24033 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion2_recv(struct tevent_req *req,
24034 : TALLOC_CTX *mem_ctx,
24035 : WERROR *result)
24036 : {
24037 0 : struct dcerpc_clusapi_GetClusterVersion2_state *state = tevent_req_data(
24038 : req, struct dcerpc_clusapi_GetClusterVersion2_state);
24039 : NTSTATUS status;
24040 :
24041 0 : if (tevent_req_is_nterror(req, &status)) {
24042 0 : tevent_req_received(req);
24043 0 : return status;
24044 : }
24045 :
24046 : /* Steal possible out parameters to the callers context */
24047 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24048 :
24049 : /* Return result */
24050 0 : *result = state->orig.out.result;
24051 :
24052 0 : tevent_req_received(req);
24053 0 : return NT_STATUS_OK;
24054 : }
24055 :
24056 0 : NTSTATUS dcerpc_clusapi_GetClusterVersion2(struct dcerpc_binding_handle *h,
24057 : TALLOC_CTX *mem_ctx,
24058 : uint16_t *_lpwMajorVersion /* [out] [ref] */,
24059 : uint16_t *_lpwMinorVersion /* [out] [ref] */,
24060 : uint16_t *_lpwBuildNumber /* [out] [ref] */,
24061 : const char **_lpszVendorId /* [out] [charset(UTF16),ref] */,
24062 : const char **_lpszCSDVersion /* [out] [charset(UTF16),ref] */,
24063 : struct CLUSTER_OPERATIONAL_VERSION_INFO **_ppClusterOpVerInfo /* [out] [ref] */,
24064 : WERROR *_rpc_status /* [out] [ref] */,
24065 : WERROR *result)
24066 : {
24067 : struct clusapi_GetClusterVersion2 r;
24068 : NTSTATUS status;
24069 :
24070 : /* In parameters */
24071 :
24072 : /* Out parameters */
24073 0 : r.out.lpwMajorVersion = _lpwMajorVersion;
24074 0 : r.out.lpwMinorVersion = _lpwMinorVersion;
24075 0 : r.out.lpwBuildNumber = _lpwBuildNumber;
24076 0 : r.out.lpszVendorId = _lpszVendorId;
24077 0 : r.out.lpszCSDVersion = _lpszCSDVersion;
24078 0 : r.out.ppClusterOpVerInfo = _ppClusterOpVerInfo;
24079 0 : r.out.rpc_status = _rpc_status;
24080 :
24081 : /* Result */
24082 0 : NDR_ZERO_STRUCT(r.out.result);
24083 :
24084 0 : status = dcerpc_clusapi_GetClusterVersion2_r(h, mem_ctx, &r);
24085 0 : if (!NT_STATUS_IS_OK(status)) {
24086 0 : return status;
24087 : }
24088 :
24089 : /* Return variables */
24090 0 : *_lpwMajorVersion = *r.out.lpwMajorVersion;
24091 0 : *_lpwMinorVersion = *r.out.lpwMinorVersion;
24092 0 : *_lpwBuildNumber = *r.out.lpwBuildNumber;
24093 0 : *_lpszVendorId = *r.out.lpszVendorId;
24094 0 : *_lpszCSDVersion = *r.out.lpszCSDVersion;
24095 0 : *_ppClusterOpVerInfo = *r.out.ppClusterOpVerInfo;
24096 0 : *_rpc_status = *r.out.rpc_status;
24097 :
24098 : /* Return result */
24099 0 : *result = r.out.result;
24100 :
24101 0 : return NT_STATUS_OK;
24102 : }
24103 :
24104 : struct dcerpc_clusapi_CreateResTypeEnum_r_state {
24105 : TALLOC_CTX *out_mem_ctx;
24106 : };
24107 :
24108 : static void dcerpc_clusapi_CreateResTypeEnum_r_done(struct tevent_req *subreq);
24109 :
24110 0 : struct tevent_req *dcerpc_clusapi_CreateResTypeEnum_r_send(TALLOC_CTX *mem_ctx,
24111 : struct tevent_context *ev,
24112 : struct dcerpc_binding_handle *h,
24113 : struct clusapi_CreateResTypeEnum *r)
24114 : {
24115 : struct tevent_req *req;
24116 : struct dcerpc_clusapi_CreateResTypeEnum_r_state *state;
24117 : struct tevent_req *subreq;
24118 :
24119 0 : req = tevent_req_create(mem_ctx, &state,
24120 : struct dcerpc_clusapi_CreateResTypeEnum_r_state);
24121 0 : if (req == NULL) {
24122 0 : return NULL;
24123 : }
24124 :
24125 0 : state->out_mem_ctx = talloc_new(state);
24126 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24127 0 : return tevent_req_post(req, ev);
24128 : }
24129 :
24130 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
24131 : NULL, &ndr_table_clusapi,
24132 0 : NDR_CLUSAPI_CREATERESTYPEENUM, state->out_mem_ctx, r);
24133 0 : if (tevent_req_nomem(subreq, req)) {
24134 0 : return tevent_req_post(req, ev);
24135 : }
24136 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResTypeEnum_r_done, req);
24137 :
24138 0 : return req;
24139 : }
24140 :
24141 0 : static void dcerpc_clusapi_CreateResTypeEnum_r_done(struct tevent_req *subreq)
24142 : {
24143 0 : struct tevent_req *req =
24144 0 : tevent_req_callback_data(subreq,
24145 : struct tevent_req);
24146 : NTSTATUS status;
24147 :
24148 0 : status = dcerpc_binding_handle_call_recv(subreq);
24149 0 : TALLOC_FREE(subreq);
24150 0 : if (tevent_req_nterror(req, status)) {
24151 0 : return;
24152 : }
24153 :
24154 0 : tevent_req_done(req);
24155 : }
24156 :
24157 0 : NTSTATUS dcerpc_clusapi_CreateResTypeEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
24158 : {
24159 0 : struct dcerpc_clusapi_CreateResTypeEnum_r_state *state =
24160 0 : tevent_req_data(req,
24161 : struct dcerpc_clusapi_CreateResTypeEnum_r_state);
24162 : NTSTATUS status;
24163 :
24164 0 : if (tevent_req_is_nterror(req, &status)) {
24165 0 : tevent_req_received(req);
24166 0 : return status;
24167 : }
24168 :
24169 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24170 :
24171 0 : tevent_req_received(req);
24172 0 : return NT_STATUS_OK;
24173 : }
24174 :
24175 0 : NTSTATUS dcerpc_clusapi_CreateResTypeEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateResTypeEnum *r)
24176 : {
24177 : NTSTATUS status;
24178 :
24179 0 : status = dcerpc_binding_handle_call(h,
24180 : NULL, &ndr_table_clusapi,
24181 : NDR_CLUSAPI_CREATERESTYPEENUM, mem_ctx, r);
24182 :
24183 0 : return status;
24184 : }
24185 :
24186 : struct dcerpc_clusapi_CreateResTypeEnum_state {
24187 : struct clusapi_CreateResTypeEnum orig;
24188 : struct clusapi_CreateResTypeEnum tmp;
24189 : TALLOC_CTX *out_mem_ctx;
24190 : };
24191 :
24192 : static void dcerpc_clusapi_CreateResTypeEnum_done(struct tevent_req *subreq);
24193 :
24194 0 : struct tevent_req *dcerpc_clusapi_CreateResTypeEnum_send(TALLOC_CTX *mem_ctx,
24195 : struct tevent_context *ev,
24196 : struct dcerpc_binding_handle *h,
24197 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
24198 : uint32_t _dwType /* [in] */,
24199 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
24200 : WERROR *_rpc_status /* [out] [ref] */)
24201 : {
24202 : struct tevent_req *req;
24203 : struct dcerpc_clusapi_CreateResTypeEnum_state *state;
24204 : struct tevent_req *subreq;
24205 :
24206 0 : req = tevent_req_create(mem_ctx, &state,
24207 : struct dcerpc_clusapi_CreateResTypeEnum_state);
24208 0 : if (req == NULL) {
24209 0 : return NULL;
24210 : }
24211 0 : state->out_mem_ctx = NULL;
24212 :
24213 : /* In parameters */
24214 0 : state->orig.in.lpszTypeName = _lpszTypeName;
24215 0 : state->orig.in.dwType = _dwType;
24216 :
24217 : /* Out parameters */
24218 0 : state->orig.out.ReturnEnum = _ReturnEnum;
24219 0 : state->orig.out.rpc_status = _rpc_status;
24220 :
24221 : /* Result */
24222 0 : NDR_ZERO_STRUCT(state->orig.out.result);
24223 :
24224 0 : state->out_mem_ctx = talloc_named_const(state, 0,
24225 : "dcerpc_clusapi_CreateResTypeEnum_out_memory");
24226 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24227 0 : return tevent_req_post(req, ev);
24228 : }
24229 :
24230 : /* make a temporary copy, that we pass to the dispatch function */
24231 0 : state->tmp = state->orig;
24232 :
24233 0 : subreq = dcerpc_clusapi_CreateResTypeEnum_r_send(state, ev, h, &state->tmp);
24234 0 : if (tevent_req_nomem(subreq, req)) {
24235 0 : return tevent_req_post(req, ev);
24236 : }
24237 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResTypeEnum_done, req);
24238 0 : return req;
24239 : }
24240 :
24241 0 : static void dcerpc_clusapi_CreateResTypeEnum_done(struct tevent_req *subreq)
24242 : {
24243 0 : struct tevent_req *req = tevent_req_callback_data(
24244 : subreq, struct tevent_req);
24245 0 : struct dcerpc_clusapi_CreateResTypeEnum_state *state = tevent_req_data(
24246 : req, struct dcerpc_clusapi_CreateResTypeEnum_state);
24247 : NTSTATUS status;
24248 : TALLOC_CTX *mem_ctx;
24249 :
24250 0 : if (state->out_mem_ctx) {
24251 0 : mem_ctx = state->out_mem_ctx;
24252 : } else {
24253 0 : mem_ctx = state;
24254 : }
24255 :
24256 0 : status = dcerpc_clusapi_CreateResTypeEnum_r_recv(subreq, mem_ctx);
24257 0 : TALLOC_FREE(subreq);
24258 0 : if (tevent_req_nterror(req, status)) {
24259 0 : return;
24260 : }
24261 :
24262 : /* Copy out parameters */
24263 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
24264 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
24265 :
24266 : /* Copy result */
24267 0 : state->orig.out.result = state->tmp.out.result;
24268 :
24269 : /* Reset temporary structure */
24270 0 : NDR_ZERO_STRUCT(state->tmp);
24271 :
24272 0 : tevent_req_done(req);
24273 : }
24274 :
24275 0 : NTSTATUS dcerpc_clusapi_CreateResTypeEnum_recv(struct tevent_req *req,
24276 : TALLOC_CTX *mem_ctx,
24277 : WERROR *result)
24278 : {
24279 0 : struct dcerpc_clusapi_CreateResTypeEnum_state *state = tevent_req_data(
24280 : req, struct dcerpc_clusapi_CreateResTypeEnum_state);
24281 : NTSTATUS status;
24282 :
24283 0 : if (tevent_req_is_nterror(req, &status)) {
24284 0 : tevent_req_received(req);
24285 0 : return status;
24286 : }
24287 :
24288 : /* Steal possible out parameters to the callers context */
24289 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24290 :
24291 : /* Return result */
24292 0 : *result = state->orig.out.result;
24293 :
24294 0 : tevent_req_received(req);
24295 0 : return NT_STATUS_OK;
24296 : }
24297 :
24298 0 : NTSTATUS dcerpc_clusapi_CreateResTypeEnum(struct dcerpc_binding_handle *h,
24299 : TALLOC_CTX *mem_ctx,
24300 : const char *_lpszTypeName /* [in] [charset(UTF16),ref] */,
24301 : uint32_t _dwType /* [in] */,
24302 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
24303 : WERROR *_rpc_status /* [out] [ref] */,
24304 : WERROR *result)
24305 : {
24306 : struct clusapi_CreateResTypeEnum r;
24307 : NTSTATUS status;
24308 :
24309 : /* In parameters */
24310 0 : r.in.lpszTypeName = _lpszTypeName;
24311 0 : r.in.dwType = _dwType;
24312 :
24313 : /* Out parameters */
24314 0 : r.out.ReturnEnum = _ReturnEnum;
24315 0 : r.out.rpc_status = _rpc_status;
24316 :
24317 : /* Result */
24318 0 : NDR_ZERO_STRUCT(r.out.result);
24319 :
24320 0 : status = dcerpc_clusapi_CreateResTypeEnum_r(h, mem_ctx, &r);
24321 0 : if (!NT_STATUS_IS_OK(status)) {
24322 0 : return status;
24323 : }
24324 :
24325 : /* Return variables */
24326 0 : *_ReturnEnum = *r.out.ReturnEnum;
24327 0 : *_rpc_status = *r.out.rpc_status;
24328 :
24329 : /* Return result */
24330 0 : *result = r.out.result;
24331 :
24332 0 : return NT_STATUS_OK;
24333 : }
24334 :
24335 : struct dcerpc_clusapi_BackupClusterDatabase_r_state {
24336 : TALLOC_CTX *out_mem_ctx;
24337 : };
24338 :
24339 : static void dcerpc_clusapi_BackupClusterDatabase_r_done(struct tevent_req *subreq);
24340 :
24341 0 : struct tevent_req *dcerpc_clusapi_BackupClusterDatabase_r_send(TALLOC_CTX *mem_ctx,
24342 : struct tevent_context *ev,
24343 : struct dcerpc_binding_handle *h,
24344 : struct clusapi_BackupClusterDatabase *r)
24345 : {
24346 : struct tevent_req *req;
24347 : struct dcerpc_clusapi_BackupClusterDatabase_r_state *state;
24348 : struct tevent_req *subreq;
24349 :
24350 0 : req = tevent_req_create(mem_ctx, &state,
24351 : struct dcerpc_clusapi_BackupClusterDatabase_r_state);
24352 0 : if (req == NULL) {
24353 0 : return NULL;
24354 : }
24355 :
24356 0 : state->out_mem_ctx = talloc_new(state);
24357 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24358 0 : return tevent_req_post(req, ev);
24359 : }
24360 :
24361 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
24362 : NULL, &ndr_table_clusapi,
24363 0 : NDR_CLUSAPI_BACKUPCLUSTERDATABASE, state->out_mem_ctx, r);
24364 0 : if (tevent_req_nomem(subreq, req)) {
24365 0 : return tevent_req_post(req, ev);
24366 : }
24367 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_BackupClusterDatabase_r_done, req);
24368 :
24369 0 : return req;
24370 : }
24371 :
24372 0 : static void dcerpc_clusapi_BackupClusterDatabase_r_done(struct tevent_req *subreq)
24373 : {
24374 0 : struct tevent_req *req =
24375 0 : tevent_req_callback_data(subreq,
24376 : struct tevent_req);
24377 : NTSTATUS status;
24378 :
24379 0 : status = dcerpc_binding_handle_call_recv(subreq);
24380 0 : TALLOC_FREE(subreq);
24381 0 : if (tevent_req_nterror(req, status)) {
24382 0 : return;
24383 : }
24384 :
24385 0 : tevent_req_done(req);
24386 : }
24387 :
24388 0 : NTSTATUS dcerpc_clusapi_BackupClusterDatabase_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
24389 : {
24390 0 : struct dcerpc_clusapi_BackupClusterDatabase_r_state *state =
24391 0 : tevent_req_data(req,
24392 : struct dcerpc_clusapi_BackupClusterDatabase_r_state);
24393 : NTSTATUS status;
24394 :
24395 0 : if (tevent_req_is_nterror(req, &status)) {
24396 0 : tevent_req_received(req);
24397 0 : return status;
24398 : }
24399 :
24400 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24401 :
24402 0 : tevent_req_received(req);
24403 0 : return NT_STATUS_OK;
24404 : }
24405 :
24406 0 : NTSTATUS dcerpc_clusapi_BackupClusterDatabase_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_BackupClusterDatabase *r)
24407 : {
24408 : NTSTATUS status;
24409 :
24410 0 : status = dcerpc_binding_handle_call(h,
24411 : NULL, &ndr_table_clusapi,
24412 : NDR_CLUSAPI_BACKUPCLUSTERDATABASE, mem_ctx, r);
24413 :
24414 0 : return status;
24415 : }
24416 :
24417 : struct dcerpc_clusapi_BackupClusterDatabase_state {
24418 : struct clusapi_BackupClusterDatabase orig;
24419 : struct clusapi_BackupClusterDatabase tmp;
24420 : TALLOC_CTX *out_mem_ctx;
24421 : };
24422 :
24423 : static void dcerpc_clusapi_BackupClusterDatabase_done(struct tevent_req *subreq);
24424 :
24425 0 : struct tevent_req *dcerpc_clusapi_BackupClusterDatabase_send(TALLOC_CTX *mem_ctx,
24426 : struct tevent_context *ev,
24427 : struct dcerpc_binding_handle *h,
24428 : const char *_lpszPathName /* [in] [charset(UTF16),ref] */,
24429 : WERROR *_rpc_status /* [out] [ref] */)
24430 : {
24431 : struct tevent_req *req;
24432 : struct dcerpc_clusapi_BackupClusterDatabase_state *state;
24433 : struct tevent_req *subreq;
24434 :
24435 0 : req = tevent_req_create(mem_ctx, &state,
24436 : struct dcerpc_clusapi_BackupClusterDatabase_state);
24437 0 : if (req == NULL) {
24438 0 : return NULL;
24439 : }
24440 0 : state->out_mem_ctx = NULL;
24441 :
24442 : /* In parameters */
24443 0 : state->orig.in.lpszPathName = _lpszPathName;
24444 :
24445 : /* Out parameters */
24446 0 : state->orig.out.rpc_status = _rpc_status;
24447 :
24448 : /* Result */
24449 0 : NDR_ZERO_STRUCT(state->orig.out.result);
24450 :
24451 0 : state->out_mem_ctx = talloc_named_const(state, 0,
24452 : "dcerpc_clusapi_BackupClusterDatabase_out_memory");
24453 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24454 0 : return tevent_req_post(req, ev);
24455 : }
24456 :
24457 : /* make a temporary copy, that we pass to the dispatch function */
24458 0 : state->tmp = state->orig;
24459 :
24460 0 : subreq = dcerpc_clusapi_BackupClusterDatabase_r_send(state, ev, h, &state->tmp);
24461 0 : if (tevent_req_nomem(subreq, req)) {
24462 0 : return tevent_req_post(req, ev);
24463 : }
24464 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_BackupClusterDatabase_done, req);
24465 0 : return req;
24466 : }
24467 :
24468 0 : static void dcerpc_clusapi_BackupClusterDatabase_done(struct tevent_req *subreq)
24469 : {
24470 0 : struct tevent_req *req = tevent_req_callback_data(
24471 : subreq, struct tevent_req);
24472 0 : struct dcerpc_clusapi_BackupClusterDatabase_state *state = tevent_req_data(
24473 : req, struct dcerpc_clusapi_BackupClusterDatabase_state);
24474 : NTSTATUS status;
24475 : TALLOC_CTX *mem_ctx;
24476 :
24477 0 : if (state->out_mem_ctx) {
24478 0 : mem_ctx = state->out_mem_ctx;
24479 : } else {
24480 0 : mem_ctx = state;
24481 : }
24482 :
24483 0 : status = dcerpc_clusapi_BackupClusterDatabase_r_recv(subreq, mem_ctx);
24484 0 : TALLOC_FREE(subreq);
24485 0 : if (tevent_req_nterror(req, status)) {
24486 0 : return;
24487 : }
24488 :
24489 : /* Copy out parameters */
24490 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
24491 :
24492 : /* Copy result */
24493 0 : state->orig.out.result = state->tmp.out.result;
24494 :
24495 : /* Reset temporary structure */
24496 0 : NDR_ZERO_STRUCT(state->tmp);
24497 :
24498 0 : tevent_req_done(req);
24499 : }
24500 :
24501 0 : NTSTATUS dcerpc_clusapi_BackupClusterDatabase_recv(struct tevent_req *req,
24502 : TALLOC_CTX *mem_ctx,
24503 : WERROR *result)
24504 : {
24505 0 : struct dcerpc_clusapi_BackupClusterDatabase_state *state = tevent_req_data(
24506 : req, struct dcerpc_clusapi_BackupClusterDatabase_state);
24507 : NTSTATUS status;
24508 :
24509 0 : if (tevent_req_is_nterror(req, &status)) {
24510 0 : tevent_req_received(req);
24511 0 : return status;
24512 : }
24513 :
24514 : /* Steal possible out parameters to the callers context */
24515 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24516 :
24517 : /* Return result */
24518 0 : *result = state->orig.out.result;
24519 :
24520 0 : tevent_req_received(req);
24521 0 : return NT_STATUS_OK;
24522 : }
24523 :
24524 0 : NTSTATUS dcerpc_clusapi_BackupClusterDatabase(struct dcerpc_binding_handle *h,
24525 : TALLOC_CTX *mem_ctx,
24526 : const char *_lpszPathName /* [in] [charset(UTF16),ref] */,
24527 : WERROR *_rpc_status /* [out] [ref] */,
24528 : WERROR *result)
24529 : {
24530 : struct clusapi_BackupClusterDatabase r;
24531 : NTSTATUS status;
24532 :
24533 : /* In parameters */
24534 0 : r.in.lpszPathName = _lpszPathName;
24535 :
24536 : /* Out parameters */
24537 0 : r.out.rpc_status = _rpc_status;
24538 :
24539 : /* Result */
24540 0 : NDR_ZERO_STRUCT(r.out.result);
24541 :
24542 0 : status = dcerpc_clusapi_BackupClusterDatabase_r(h, mem_ctx, &r);
24543 0 : if (!NT_STATUS_IS_OK(status)) {
24544 0 : return status;
24545 : }
24546 :
24547 : /* Return variables */
24548 0 : *_rpc_status = *r.out.rpc_status;
24549 :
24550 : /* Return result */
24551 0 : *result = r.out.result;
24552 :
24553 0 : return NT_STATUS_OK;
24554 : }
24555 :
24556 : struct dcerpc_clusapi_NodeClusterControl_r_state {
24557 : TALLOC_CTX *out_mem_ctx;
24558 : };
24559 :
24560 : static void dcerpc_clusapi_NodeClusterControl_r_done(struct tevent_req *subreq);
24561 :
24562 0 : struct tevent_req *dcerpc_clusapi_NodeClusterControl_r_send(TALLOC_CTX *mem_ctx,
24563 : struct tevent_context *ev,
24564 : struct dcerpc_binding_handle *h,
24565 : struct clusapi_NodeClusterControl *r)
24566 : {
24567 : struct tevent_req *req;
24568 : struct dcerpc_clusapi_NodeClusterControl_r_state *state;
24569 : struct tevent_req *subreq;
24570 :
24571 0 : req = tevent_req_create(mem_ctx, &state,
24572 : struct dcerpc_clusapi_NodeClusterControl_r_state);
24573 0 : if (req == NULL) {
24574 0 : return NULL;
24575 : }
24576 :
24577 0 : state->out_mem_ctx = talloc_new(state);
24578 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24579 0 : return tevent_req_post(req, ev);
24580 : }
24581 :
24582 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
24583 : NULL, &ndr_table_clusapi,
24584 0 : NDR_CLUSAPI_NODECLUSTERCONTROL, state->out_mem_ctx, r);
24585 0 : if (tevent_req_nomem(subreq, req)) {
24586 0 : return tevent_req_post(req, ev);
24587 : }
24588 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeClusterControl_r_done, req);
24589 :
24590 0 : return req;
24591 : }
24592 :
24593 0 : static void dcerpc_clusapi_NodeClusterControl_r_done(struct tevent_req *subreq)
24594 : {
24595 0 : struct tevent_req *req =
24596 0 : tevent_req_callback_data(subreq,
24597 : struct tevent_req);
24598 : NTSTATUS status;
24599 :
24600 0 : status = dcerpc_binding_handle_call_recv(subreq);
24601 0 : TALLOC_FREE(subreq);
24602 0 : if (tevent_req_nterror(req, status)) {
24603 0 : return;
24604 : }
24605 :
24606 0 : tevent_req_done(req);
24607 : }
24608 :
24609 0 : NTSTATUS dcerpc_clusapi_NodeClusterControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
24610 : {
24611 0 : struct dcerpc_clusapi_NodeClusterControl_r_state *state =
24612 0 : tevent_req_data(req,
24613 : struct dcerpc_clusapi_NodeClusterControl_r_state);
24614 : NTSTATUS status;
24615 :
24616 0 : if (tevent_req_is_nterror(req, &status)) {
24617 0 : tevent_req_received(req);
24618 0 : return status;
24619 : }
24620 :
24621 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24622 :
24623 0 : tevent_req_received(req);
24624 0 : return NT_STATUS_OK;
24625 : }
24626 :
24627 0 : NTSTATUS dcerpc_clusapi_NodeClusterControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeClusterControl *r)
24628 : {
24629 : NTSTATUS status;
24630 :
24631 0 : status = dcerpc_binding_handle_call(h,
24632 : NULL, &ndr_table_clusapi,
24633 : NDR_CLUSAPI_NODECLUSTERCONTROL, mem_ctx, r);
24634 :
24635 0 : return status;
24636 : }
24637 :
24638 : struct dcerpc_clusapi_NodeClusterControl_state {
24639 : struct clusapi_NodeClusterControl orig;
24640 : struct clusapi_NodeClusterControl tmp;
24641 : TALLOC_CTX *out_mem_ctx;
24642 : };
24643 :
24644 : static void dcerpc_clusapi_NodeClusterControl_done(struct tevent_req *subreq);
24645 :
24646 0 : struct tevent_req *dcerpc_clusapi_NodeClusterControl_send(TALLOC_CTX *mem_ctx,
24647 : struct tevent_context *ev,
24648 : struct dcerpc_binding_handle *h,
24649 : struct policy_handle _hCluster /* [in] */,
24650 : struct policy_handle _hHostNode /* [in] */,
24651 : uint32_t _dwControlCode /* [in] */,
24652 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
24653 : uint32_t _nInBufferSize /* [in] */,
24654 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
24655 : uint32_t _nOutBufferSize /* [in] */,
24656 : uint32_t *_lpBytesReturned /* [out] [ref] */,
24657 : uint32_t *_lpcbRequired /* [out] [ref] */,
24658 : WERROR *_rpc_status /* [out] [ref] */)
24659 : {
24660 : struct tevent_req *req;
24661 : struct dcerpc_clusapi_NodeClusterControl_state *state;
24662 : struct tevent_req *subreq;
24663 :
24664 0 : req = tevent_req_create(mem_ctx, &state,
24665 : struct dcerpc_clusapi_NodeClusterControl_state);
24666 0 : if (req == NULL) {
24667 0 : return NULL;
24668 : }
24669 0 : state->out_mem_ctx = NULL;
24670 :
24671 : /* In parameters */
24672 0 : state->orig.in.hCluster = _hCluster;
24673 0 : state->orig.in.hHostNode = _hHostNode;
24674 0 : state->orig.in.dwControlCode = _dwControlCode;
24675 0 : state->orig.in.lpInBuffer = _lpInBuffer;
24676 0 : state->orig.in.nInBufferSize = _nInBufferSize;
24677 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
24678 :
24679 : /* Out parameters */
24680 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
24681 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
24682 0 : state->orig.out.lpcbRequired = _lpcbRequired;
24683 0 : state->orig.out.rpc_status = _rpc_status;
24684 :
24685 : /* Result */
24686 0 : NDR_ZERO_STRUCT(state->orig.out.result);
24687 :
24688 0 : state->out_mem_ctx = talloc_named_const(state, 0,
24689 : "dcerpc_clusapi_NodeClusterControl_out_memory");
24690 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24691 0 : return tevent_req_post(req, ev);
24692 : }
24693 :
24694 : /* make a temporary copy, that we pass to the dispatch function */
24695 0 : state->tmp = state->orig;
24696 :
24697 0 : subreq = dcerpc_clusapi_NodeClusterControl_r_send(state, ev, h, &state->tmp);
24698 0 : if (tevent_req_nomem(subreq, req)) {
24699 0 : return tevent_req_post(req, ev);
24700 : }
24701 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeClusterControl_done, req);
24702 0 : return req;
24703 : }
24704 :
24705 0 : static void dcerpc_clusapi_NodeClusterControl_done(struct tevent_req *subreq)
24706 : {
24707 0 : struct tevent_req *req = tevent_req_callback_data(
24708 : subreq, struct tevent_req);
24709 0 : struct dcerpc_clusapi_NodeClusterControl_state *state = tevent_req_data(
24710 : req, struct dcerpc_clusapi_NodeClusterControl_state);
24711 : NTSTATUS status;
24712 : TALLOC_CTX *mem_ctx;
24713 :
24714 0 : if (state->out_mem_ctx) {
24715 0 : mem_ctx = state->out_mem_ctx;
24716 : } else {
24717 0 : mem_ctx = state;
24718 : }
24719 :
24720 0 : status = dcerpc_clusapi_NodeClusterControl_r_recv(subreq, mem_ctx);
24721 0 : TALLOC_FREE(subreq);
24722 0 : if (tevent_req_nterror(req, status)) {
24723 0 : return;
24724 : }
24725 :
24726 : /* Copy out parameters */
24727 : {
24728 : size_t _copy_len_lpOutBuffer;
24729 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
24730 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
24731 0 : return;
24732 : }
24733 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
24734 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
24735 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
24736 : }
24737 : }
24738 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
24739 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
24740 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
24741 :
24742 : /* Copy result */
24743 0 : state->orig.out.result = state->tmp.out.result;
24744 :
24745 : /* Reset temporary structure */
24746 0 : NDR_ZERO_STRUCT(state->tmp);
24747 :
24748 0 : tevent_req_done(req);
24749 : }
24750 :
24751 0 : NTSTATUS dcerpc_clusapi_NodeClusterControl_recv(struct tevent_req *req,
24752 : TALLOC_CTX *mem_ctx,
24753 : WERROR *result)
24754 : {
24755 0 : struct dcerpc_clusapi_NodeClusterControl_state *state = tevent_req_data(
24756 : req, struct dcerpc_clusapi_NodeClusterControl_state);
24757 : NTSTATUS status;
24758 :
24759 0 : if (tevent_req_is_nterror(req, &status)) {
24760 0 : tevent_req_received(req);
24761 0 : return status;
24762 : }
24763 :
24764 : /* Steal possible out parameters to the callers context */
24765 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24766 :
24767 : /* Return result */
24768 0 : *result = state->orig.out.result;
24769 :
24770 0 : tevent_req_received(req);
24771 0 : return NT_STATUS_OK;
24772 : }
24773 :
24774 0 : NTSTATUS dcerpc_clusapi_NodeClusterControl(struct dcerpc_binding_handle *h,
24775 : TALLOC_CTX *mem_ctx,
24776 : struct policy_handle _hCluster /* [in] */,
24777 : struct policy_handle _hHostNode /* [in] */,
24778 : uint32_t _dwControlCode /* [in] */,
24779 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
24780 : uint32_t _nInBufferSize /* [in] */,
24781 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
24782 : uint32_t _nOutBufferSize /* [in] */,
24783 : uint32_t *_lpBytesReturned /* [out] [ref] */,
24784 : uint32_t *_lpcbRequired /* [out] [ref] */,
24785 : WERROR *_rpc_status /* [out] [ref] */,
24786 : WERROR *result)
24787 : {
24788 : struct clusapi_NodeClusterControl r;
24789 : NTSTATUS status;
24790 :
24791 : /* In parameters */
24792 0 : r.in.hCluster = _hCluster;
24793 0 : r.in.hHostNode = _hHostNode;
24794 0 : r.in.dwControlCode = _dwControlCode;
24795 0 : r.in.lpInBuffer = _lpInBuffer;
24796 0 : r.in.nInBufferSize = _nInBufferSize;
24797 0 : r.in.nOutBufferSize = _nOutBufferSize;
24798 :
24799 : /* Out parameters */
24800 0 : r.out.lpOutBuffer = _lpOutBuffer;
24801 0 : r.out.lpBytesReturned = _lpBytesReturned;
24802 0 : r.out.lpcbRequired = _lpcbRequired;
24803 0 : r.out.rpc_status = _rpc_status;
24804 :
24805 : /* Result */
24806 0 : NDR_ZERO_STRUCT(r.out.result);
24807 :
24808 0 : status = dcerpc_clusapi_NodeClusterControl_r(h, mem_ctx, &r);
24809 0 : if (!NT_STATUS_IS_OK(status)) {
24810 0 : return status;
24811 : }
24812 :
24813 : /* Return variables */
24814 : {
24815 : size_t _copy_len_lpOutBuffer;
24816 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
24817 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
24818 : }
24819 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
24820 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
24821 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
24822 : }
24823 : }
24824 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
24825 0 : *_lpcbRequired = *r.out.lpcbRequired;
24826 0 : *_rpc_status = *r.out.rpc_status;
24827 :
24828 : /* Return result */
24829 0 : *result = r.out.result;
24830 :
24831 0 : return NT_STATUS_OK;
24832 : }
24833 :
24834 : struct dcerpc_clusapi_ClusterControl_r_state {
24835 : TALLOC_CTX *out_mem_ctx;
24836 : };
24837 :
24838 : static void dcerpc_clusapi_ClusterControl_r_done(struct tevent_req *subreq);
24839 :
24840 0 : struct tevent_req *dcerpc_clusapi_ClusterControl_r_send(TALLOC_CTX *mem_ctx,
24841 : struct tevent_context *ev,
24842 : struct dcerpc_binding_handle *h,
24843 : struct clusapi_ClusterControl *r)
24844 : {
24845 : struct tevent_req *req;
24846 : struct dcerpc_clusapi_ClusterControl_r_state *state;
24847 : struct tevent_req *subreq;
24848 :
24849 0 : req = tevent_req_create(mem_ctx, &state,
24850 : struct dcerpc_clusapi_ClusterControl_r_state);
24851 0 : if (req == NULL) {
24852 0 : return NULL;
24853 : }
24854 :
24855 0 : state->out_mem_ctx = talloc_new(state);
24856 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24857 0 : return tevent_req_post(req, ev);
24858 : }
24859 :
24860 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
24861 : NULL, &ndr_table_clusapi,
24862 0 : NDR_CLUSAPI_CLUSTERCONTROL, state->out_mem_ctx, r);
24863 0 : if (tevent_req_nomem(subreq, req)) {
24864 0 : return tevent_req_post(req, ev);
24865 : }
24866 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ClusterControl_r_done, req);
24867 :
24868 0 : return req;
24869 : }
24870 :
24871 0 : static void dcerpc_clusapi_ClusterControl_r_done(struct tevent_req *subreq)
24872 : {
24873 0 : struct tevent_req *req =
24874 0 : tevent_req_callback_data(subreq,
24875 : struct tevent_req);
24876 : NTSTATUS status;
24877 :
24878 0 : status = dcerpc_binding_handle_call_recv(subreq);
24879 0 : TALLOC_FREE(subreq);
24880 0 : if (tevent_req_nterror(req, status)) {
24881 0 : return;
24882 : }
24883 :
24884 0 : tevent_req_done(req);
24885 : }
24886 :
24887 0 : NTSTATUS dcerpc_clusapi_ClusterControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
24888 : {
24889 0 : struct dcerpc_clusapi_ClusterControl_r_state *state =
24890 0 : tevent_req_data(req,
24891 : struct dcerpc_clusapi_ClusterControl_r_state);
24892 : NTSTATUS status;
24893 :
24894 0 : if (tevent_req_is_nterror(req, &status)) {
24895 0 : tevent_req_received(req);
24896 0 : return status;
24897 : }
24898 :
24899 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
24900 :
24901 0 : tevent_req_received(req);
24902 0 : return NT_STATUS_OK;
24903 : }
24904 :
24905 0 : NTSTATUS dcerpc_clusapi_ClusterControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ClusterControl *r)
24906 : {
24907 : NTSTATUS status;
24908 :
24909 0 : status = dcerpc_binding_handle_call(h,
24910 : NULL, &ndr_table_clusapi,
24911 : NDR_CLUSAPI_CLUSTERCONTROL, mem_ctx, r);
24912 :
24913 0 : return status;
24914 : }
24915 :
24916 : struct dcerpc_clusapi_ClusterControl_state {
24917 : struct clusapi_ClusterControl orig;
24918 : struct clusapi_ClusterControl tmp;
24919 : TALLOC_CTX *out_mem_ctx;
24920 : };
24921 :
24922 : static void dcerpc_clusapi_ClusterControl_done(struct tevent_req *subreq);
24923 :
24924 0 : struct tevent_req *dcerpc_clusapi_ClusterControl_send(TALLOC_CTX *mem_ctx,
24925 : struct tevent_context *ev,
24926 : struct dcerpc_binding_handle *h,
24927 : struct policy_handle _hCluster /* [in] */,
24928 : enum clusapi_ClusterControlCode _dwControlCode /* [in] */,
24929 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
24930 : uint32_t _nInBufferSize /* [in] */,
24931 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
24932 : uint32_t _nOutBufferSize /* [in] */,
24933 : uint32_t *_lpBytesReturned /* [out] [ref] */,
24934 : uint32_t *_lpcbRequired /* [out] [ref] */,
24935 : WERROR *_rpc_status /* [out] [ref] */)
24936 : {
24937 : struct tevent_req *req;
24938 : struct dcerpc_clusapi_ClusterControl_state *state;
24939 : struct tevent_req *subreq;
24940 :
24941 0 : req = tevent_req_create(mem_ctx, &state,
24942 : struct dcerpc_clusapi_ClusterControl_state);
24943 0 : if (req == NULL) {
24944 0 : return NULL;
24945 : }
24946 0 : state->out_mem_ctx = NULL;
24947 :
24948 : /* In parameters */
24949 0 : state->orig.in.hCluster = _hCluster;
24950 0 : state->orig.in.dwControlCode = _dwControlCode;
24951 0 : state->orig.in.lpInBuffer = _lpInBuffer;
24952 0 : state->orig.in.nInBufferSize = _nInBufferSize;
24953 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
24954 :
24955 : /* Out parameters */
24956 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
24957 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
24958 0 : state->orig.out.lpcbRequired = _lpcbRequired;
24959 0 : state->orig.out.rpc_status = _rpc_status;
24960 :
24961 : /* Result */
24962 0 : NDR_ZERO_STRUCT(state->orig.out.result);
24963 :
24964 0 : state->out_mem_ctx = talloc_named_const(state, 0,
24965 : "dcerpc_clusapi_ClusterControl_out_memory");
24966 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
24967 0 : return tevent_req_post(req, ev);
24968 : }
24969 :
24970 : /* make a temporary copy, that we pass to the dispatch function */
24971 0 : state->tmp = state->orig;
24972 :
24973 0 : subreq = dcerpc_clusapi_ClusterControl_r_send(state, ev, h, &state->tmp);
24974 0 : if (tevent_req_nomem(subreq, req)) {
24975 0 : return tevent_req_post(req, ev);
24976 : }
24977 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ClusterControl_done, req);
24978 0 : return req;
24979 : }
24980 :
24981 0 : static void dcerpc_clusapi_ClusterControl_done(struct tevent_req *subreq)
24982 : {
24983 0 : struct tevent_req *req = tevent_req_callback_data(
24984 : subreq, struct tevent_req);
24985 0 : struct dcerpc_clusapi_ClusterControl_state *state = tevent_req_data(
24986 : req, struct dcerpc_clusapi_ClusterControl_state);
24987 : NTSTATUS status;
24988 : TALLOC_CTX *mem_ctx;
24989 :
24990 0 : if (state->out_mem_ctx) {
24991 0 : mem_ctx = state->out_mem_ctx;
24992 : } else {
24993 0 : mem_ctx = state;
24994 : }
24995 :
24996 0 : status = dcerpc_clusapi_ClusterControl_r_recv(subreq, mem_ctx);
24997 0 : TALLOC_FREE(subreq);
24998 0 : if (tevent_req_nterror(req, status)) {
24999 0 : return;
25000 : }
25001 :
25002 : /* Copy out parameters */
25003 : {
25004 : size_t _copy_len_lpOutBuffer;
25005 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
25006 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
25007 0 : return;
25008 : }
25009 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
25010 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
25011 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
25012 : }
25013 : }
25014 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
25015 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
25016 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
25017 :
25018 : /* Copy result */
25019 0 : state->orig.out.result = state->tmp.out.result;
25020 :
25021 : /* Reset temporary structure */
25022 0 : NDR_ZERO_STRUCT(state->tmp);
25023 :
25024 0 : tevent_req_done(req);
25025 : }
25026 :
25027 0 : NTSTATUS dcerpc_clusapi_ClusterControl_recv(struct tevent_req *req,
25028 : TALLOC_CTX *mem_ctx,
25029 : WERROR *result)
25030 : {
25031 0 : struct dcerpc_clusapi_ClusterControl_state *state = tevent_req_data(
25032 : req, struct dcerpc_clusapi_ClusterControl_state);
25033 : NTSTATUS status;
25034 :
25035 0 : if (tevent_req_is_nterror(req, &status)) {
25036 0 : tevent_req_received(req);
25037 0 : return status;
25038 : }
25039 :
25040 : /* Steal possible out parameters to the callers context */
25041 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25042 :
25043 : /* Return result */
25044 0 : *result = state->orig.out.result;
25045 :
25046 0 : tevent_req_received(req);
25047 0 : return NT_STATUS_OK;
25048 : }
25049 :
25050 0 : NTSTATUS dcerpc_clusapi_ClusterControl(struct dcerpc_binding_handle *h,
25051 : TALLOC_CTX *mem_ctx,
25052 : struct policy_handle _hCluster /* [in] */,
25053 : enum clusapi_ClusterControlCode _dwControlCode /* [in] */,
25054 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
25055 : uint32_t _nInBufferSize /* [in] */,
25056 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
25057 : uint32_t _nOutBufferSize /* [in] */,
25058 : uint32_t *_lpBytesReturned /* [out] [ref] */,
25059 : uint32_t *_lpcbRequired /* [out] [ref] */,
25060 : WERROR *_rpc_status /* [out] [ref] */,
25061 : WERROR *result)
25062 : {
25063 : struct clusapi_ClusterControl r;
25064 : NTSTATUS status;
25065 :
25066 : /* In parameters */
25067 0 : r.in.hCluster = _hCluster;
25068 0 : r.in.dwControlCode = _dwControlCode;
25069 0 : r.in.lpInBuffer = _lpInBuffer;
25070 0 : r.in.nInBufferSize = _nInBufferSize;
25071 0 : r.in.nOutBufferSize = _nOutBufferSize;
25072 :
25073 : /* Out parameters */
25074 0 : r.out.lpOutBuffer = _lpOutBuffer;
25075 0 : r.out.lpBytesReturned = _lpBytesReturned;
25076 0 : r.out.lpcbRequired = _lpcbRequired;
25077 0 : r.out.rpc_status = _rpc_status;
25078 :
25079 : /* Result */
25080 0 : NDR_ZERO_STRUCT(r.out.result);
25081 :
25082 0 : status = dcerpc_clusapi_ClusterControl_r(h, mem_ctx, &r);
25083 0 : if (!NT_STATUS_IS_OK(status)) {
25084 0 : return status;
25085 : }
25086 :
25087 : /* Return variables */
25088 : {
25089 : size_t _copy_len_lpOutBuffer;
25090 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
25091 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
25092 : }
25093 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
25094 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
25095 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
25096 : }
25097 : }
25098 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
25099 0 : *_lpcbRequired = *r.out.lpcbRequired;
25100 0 : *_rpc_status = *r.out.rpc_status;
25101 :
25102 : /* Return result */
25103 0 : *result = r.out.result;
25104 :
25105 0 : return NT_STATUS_OK;
25106 : }
25107 :
25108 : struct dcerpc_clusapi_UnblockGetNotifyCall_r_state {
25109 : TALLOC_CTX *out_mem_ctx;
25110 : };
25111 :
25112 : static void dcerpc_clusapi_UnblockGetNotifyCall_r_done(struct tevent_req *subreq);
25113 :
25114 0 : struct tevent_req *dcerpc_clusapi_UnblockGetNotifyCall_r_send(TALLOC_CTX *mem_ctx,
25115 : struct tevent_context *ev,
25116 : struct dcerpc_binding_handle *h,
25117 : struct clusapi_UnblockGetNotifyCall *r)
25118 : {
25119 : struct tevent_req *req;
25120 : struct dcerpc_clusapi_UnblockGetNotifyCall_r_state *state;
25121 : struct tevent_req *subreq;
25122 :
25123 0 : req = tevent_req_create(mem_ctx, &state,
25124 : struct dcerpc_clusapi_UnblockGetNotifyCall_r_state);
25125 0 : if (req == NULL) {
25126 0 : return NULL;
25127 : }
25128 :
25129 0 : state->out_mem_ctx = NULL;
25130 :
25131 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
25132 : NULL, &ndr_table_clusapi,
25133 : NDR_CLUSAPI_UNBLOCKGETNOTIFYCALL, state, r);
25134 0 : if (tevent_req_nomem(subreq, req)) {
25135 0 : return tevent_req_post(req, ev);
25136 : }
25137 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_UnblockGetNotifyCall_r_done, req);
25138 :
25139 0 : return req;
25140 : }
25141 :
25142 0 : static void dcerpc_clusapi_UnblockGetNotifyCall_r_done(struct tevent_req *subreq)
25143 : {
25144 0 : struct tevent_req *req =
25145 0 : tevent_req_callback_data(subreq,
25146 : struct tevent_req);
25147 : NTSTATUS status;
25148 :
25149 0 : status = dcerpc_binding_handle_call_recv(subreq);
25150 0 : TALLOC_FREE(subreq);
25151 0 : if (tevent_req_nterror(req, status)) {
25152 0 : return;
25153 : }
25154 :
25155 0 : tevent_req_done(req);
25156 : }
25157 :
25158 0 : NTSTATUS dcerpc_clusapi_UnblockGetNotifyCall_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
25159 : {
25160 0 : struct dcerpc_clusapi_UnblockGetNotifyCall_r_state *state =
25161 0 : tevent_req_data(req,
25162 : struct dcerpc_clusapi_UnblockGetNotifyCall_r_state);
25163 : NTSTATUS status;
25164 :
25165 0 : if (tevent_req_is_nterror(req, &status)) {
25166 0 : tevent_req_received(req);
25167 0 : return status;
25168 : }
25169 :
25170 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25171 :
25172 0 : tevent_req_received(req);
25173 0 : return NT_STATUS_OK;
25174 : }
25175 :
25176 0 : NTSTATUS dcerpc_clusapi_UnblockGetNotifyCall_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_UnblockGetNotifyCall *r)
25177 : {
25178 : NTSTATUS status;
25179 :
25180 0 : status = dcerpc_binding_handle_call(h,
25181 : NULL, &ndr_table_clusapi,
25182 : NDR_CLUSAPI_UNBLOCKGETNOTIFYCALL, mem_ctx, r);
25183 :
25184 0 : return status;
25185 : }
25186 :
25187 : struct dcerpc_clusapi_UnblockGetNotifyCall_state {
25188 : struct clusapi_UnblockGetNotifyCall orig;
25189 : struct clusapi_UnblockGetNotifyCall tmp;
25190 : TALLOC_CTX *out_mem_ctx;
25191 : };
25192 :
25193 : static void dcerpc_clusapi_UnblockGetNotifyCall_done(struct tevent_req *subreq);
25194 :
25195 0 : struct tevent_req *dcerpc_clusapi_UnblockGetNotifyCall_send(TALLOC_CTX *mem_ctx,
25196 : struct tevent_context *ev,
25197 : struct dcerpc_binding_handle *h,
25198 : struct policy_handle _hNotify /* [in] */)
25199 : {
25200 : struct tevent_req *req;
25201 : struct dcerpc_clusapi_UnblockGetNotifyCall_state *state;
25202 : struct tevent_req *subreq;
25203 :
25204 0 : req = tevent_req_create(mem_ctx, &state,
25205 : struct dcerpc_clusapi_UnblockGetNotifyCall_state);
25206 0 : if (req == NULL) {
25207 0 : return NULL;
25208 : }
25209 0 : state->out_mem_ctx = NULL;
25210 :
25211 : /* In parameters */
25212 0 : state->orig.in.hNotify = _hNotify;
25213 :
25214 : /* Out parameters */
25215 :
25216 : /* Result */
25217 0 : NDR_ZERO_STRUCT(state->orig.out.result);
25218 :
25219 : /* make a temporary copy, that we pass to the dispatch function */
25220 0 : state->tmp = state->orig;
25221 :
25222 0 : subreq = dcerpc_clusapi_UnblockGetNotifyCall_r_send(state, ev, h, &state->tmp);
25223 0 : if (tevent_req_nomem(subreq, req)) {
25224 0 : return tevent_req_post(req, ev);
25225 : }
25226 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_UnblockGetNotifyCall_done, req);
25227 0 : return req;
25228 : }
25229 :
25230 0 : static void dcerpc_clusapi_UnblockGetNotifyCall_done(struct tevent_req *subreq)
25231 : {
25232 0 : struct tevent_req *req = tevent_req_callback_data(
25233 : subreq, struct tevent_req);
25234 0 : struct dcerpc_clusapi_UnblockGetNotifyCall_state *state = tevent_req_data(
25235 : req, struct dcerpc_clusapi_UnblockGetNotifyCall_state);
25236 : NTSTATUS status;
25237 : TALLOC_CTX *mem_ctx;
25238 :
25239 0 : if (state->out_mem_ctx) {
25240 0 : mem_ctx = state->out_mem_ctx;
25241 : } else {
25242 0 : mem_ctx = state;
25243 : }
25244 :
25245 0 : status = dcerpc_clusapi_UnblockGetNotifyCall_r_recv(subreq, mem_ctx);
25246 0 : TALLOC_FREE(subreq);
25247 0 : if (tevent_req_nterror(req, status)) {
25248 0 : return;
25249 : }
25250 :
25251 : /* Copy out parameters */
25252 :
25253 : /* Copy result */
25254 0 : state->orig.out.result = state->tmp.out.result;
25255 :
25256 : /* Reset temporary structure */
25257 0 : NDR_ZERO_STRUCT(state->tmp);
25258 :
25259 0 : tevent_req_done(req);
25260 : }
25261 :
25262 0 : NTSTATUS dcerpc_clusapi_UnblockGetNotifyCall_recv(struct tevent_req *req,
25263 : TALLOC_CTX *mem_ctx,
25264 : WERROR *result)
25265 : {
25266 0 : struct dcerpc_clusapi_UnblockGetNotifyCall_state *state = tevent_req_data(
25267 : req, struct dcerpc_clusapi_UnblockGetNotifyCall_state);
25268 : NTSTATUS status;
25269 :
25270 0 : if (tevent_req_is_nterror(req, &status)) {
25271 0 : tevent_req_received(req);
25272 0 : return status;
25273 : }
25274 :
25275 : /* Steal possible out parameters to the callers context */
25276 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25277 :
25278 : /* Return result */
25279 0 : *result = state->orig.out.result;
25280 :
25281 0 : tevent_req_received(req);
25282 0 : return NT_STATUS_OK;
25283 : }
25284 :
25285 0 : NTSTATUS dcerpc_clusapi_UnblockGetNotifyCall(struct dcerpc_binding_handle *h,
25286 : TALLOC_CTX *mem_ctx,
25287 : struct policy_handle _hNotify /* [in] */,
25288 : WERROR *result)
25289 : {
25290 : struct clusapi_UnblockGetNotifyCall r;
25291 : NTSTATUS status;
25292 :
25293 : /* In parameters */
25294 0 : r.in.hNotify = _hNotify;
25295 :
25296 : /* Out parameters */
25297 :
25298 : /* Result */
25299 0 : NDR_ZERO_STRUCT(r.out.result);
25300 :
25301 0 : status = dcerpc_clusapi_UnblockGetNotifyCall_r(h, mem_ctx, &r);
25302 0 : if (!NT_STATUS_IS_OK(status)) {
25303 0 : return status;
25304 : }
25305 :
25306 : /* Return variables */
25307 :
25308 : /* Return result */
25309 0 : *result = r.out.result;
25310 :
25311 0 : return NT_STATUS_OK;
25312 : }
25313 :
25314 : struct dcerpc_clusapi_SetServiceAccountPassword_r_state {
25315 : TALLOC_CTX *out_mem_ctx;
25316 : };
25317 :
25318 : static void dcerpc_clusapi_SetServiceAccountPassword_r_done(struct tevent_req *subreq);
25319 :
25320 0 : struct tevent_req *dcerpc_clusapi_SetServiceAccountPassword_r_send(TALLOC_CTX *mem_ctx,
25321 : struct tevent_context *ev,
25322 : struct dcerpc_binding_handle *h,
25323 : struct clusapi_SetServiceAccountPassword *r)
25324 : {
25325 : struct tevent_req *req;
25326 : struct dcerpc_clusapi_SetServiceAccountPassword_r_state *state;
25327 : struct tevent_req *subreq;
25328 :
25329 0 : req = tevent_req_create(mem_ctx, &state,
25330 : struct dcerpc_clusapi_SetServiceAccountPassword_r_state);
25331 0 : if (req == NULL) {
25332 0 : return NULL;
25333 : }
25334 :
25335 0 : state->out_mem_ctx = talloc_new(state);
25336 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25337 0 : return tevent_req_post(req, ev);
25338 : }
25339 :
25340 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
25341 : NULL, &ndr_table_clusapi,
25342 0 : NDR_CLUSAPI_SETSERVICEACCOUNTPASSWORD, state->out_mem_ctx, r);
25343 0 : if (tevent_req_nomem(subreq, req)) {
25344 0 : return tevent_req_post(req, ev);
25345 : }
25346 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetServiceAccountPassword_r_done, req);
25347 :
25348 0 : return req;
25349 : }
25350 :
25351 0 : static void dcerpc_clusapi_SetServiceAccountPassword_r_done(struct tevent_req *subreq)
25352 : {
25353 0 : struct tevent_req *req =
25354 0 : tevent_req_callback_data(subreq,
25355 : struct tevent_req);
25356 : NTSTATUS status;
25357 :
25358 0 : status = dcerpc_binding_handle_call_recv(subreq);
25359 0 : TALLOC_FREE(subreq);
25360 0 : if (tevent_req_nterror(req, status)) {
25361 0 : return;
25362 : }
25363 :
25364 0 : tevent_req_done(req);
25365 : }
25366 :
25367 0 : NTSTATUS dcerpc_clusapi_SetServiceAccountPassword_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
25368 : {
25369 0 : struct dcerpc_clusapi_SetServiceAccountPassword_r_state *state =
25370 0 : tevent_req_data(req,
25371 : struct dcerpc_clusapi_SetServiceAccountPassword_r_state);
25372 : NTSTATUS status;
25373 :
25374 0 : if (tevent_req_is_nterror(req, &status)) {
25375 0 : tevent_req_received(req);
25376 0 : return status;
25377 : }
25378 :
25379 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25380 :
25381 0 : tevent_req_received(req);
25382 0 : return NT_STATUS_OK;
25383 : }
25384 :
25385 0 : NTSTATUS dcerpc_clusapi_SetServiceAccountPassword_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetServiceAccountPassword *r)
25386 : {
25387 : NTSTATUS status;
25388 :
25389 0 : status = dcerpc_binding_handle_call(h,
25390 : NULL, &ndr_table_clusapi,
25391 : NDR_CLUSAPI_SETSERVICEACCOUNTPASSWORD, mem_ctx, r);
25392 :
25393 0 : return status;
25394 : }
25395 :
25396 : struct dcerpc_clusapi_SetServiceAccountPassword_state {
25397 : struct clusapi_SetServiceAccountPassword orig;
25398 : struct clusapi_SetServiceAccountPassword tmp;
25399 : TALLOC_CTX *out_mem_ctx;
25400 : };
25401 :
25402 : static void dcerpc_clusapi_SetServiceAccountPassword_done(struct tevent_req *subreq);
25403 :
25404 0 : struct tevent_req *dcerpc_clusapi_SetServiceAccountPassword_send(TALLOC_CTX *mem_ctx,
25405 : struct tevent_context *ev,
25406 : struct dcerpc_binding_handle *h,
25407 : const char *_lpszNewPassword /* [in] [charset(UTF16),ref] */,
25408 : enum IDL_CLUSTER_SET_PASSWORD_FLAGS _dwFlags /* [in] */,
25409 : struct IDL_CLUSTER_SET_PASSWORD_STATUS *_ReturnStatusBufferPtr /* [out] [length_is(*SizeReturned),size_is(ReturnStatusBufferSize)] */,
25410 : uint32_t _ReturnStatusBufferSize /* [in] [range(0,(64*1024))] */,
25411 : uint32_t *_SizeReturned /* [out] [ref] */,
25412 : uint32_t *_ExpectedBufferSize /* [out] [ref] */)
25413 : {
25414 : struct tevent_req *req;
25415 : struct dcerpc_clusapi_SetServiceAccountPassword_state *state;
25416 : struct tevent_req *subreq;
25417 :
25418 0 : req = tevent_req_create(mem_ctx, &state,
25419 : struct dcerpc_clusapi_SetServiceAccountPassword_state);
25420 0 : if (req == NULL) {
25421 0 : return NULL;
25422 : }
25423 0 : state->out_mem_ctx = NULL;
25424 :
25425 : /* In parameters */
25426 0 : state->orig.in.lpszNewPassword = _lpszNewPassword;
25427 0 : state->orig.in.dwFlags = _dwFlags;
25428 0 : state->orig.in.ReturnStatusBufferSize = _ReturnStatusBufferSize;
25429 :
25430 : /* Out parameters */
25431 0 : state->orig.out.ReturnStatusBufferPtr = _ReturnStatusBufferPtr;
25432 0 : state->orig.out.SizeReturned = _SizeReturned;
25433 0 : state->orig.out.ExpectedBufferSize = _ExpectedBufferSize;
25434 :
25435 : /* Result */
25436 0 : NDR_ZERO_STRUCT(state->orig.out.result);
25437 :
25438 0 : state->out_mem_ctx = talloc_named_const(state, 0,
25439 : "dcerpc_clusapi_SetServiceAccountPassword_out_memory");
25440 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25441 0 : return tevent_req_post(req, ev);
25442 : }
25443 :
25444 : /* make a temporary copy, that we pass to the dispatch function */
25445 0 : state->tmp = state->orig;
25446 :
25447 0 : subreq = dcerpc_clusapi_SetServiceAccountPassword_r_send(state, ev, h, &state->tmp);
25448 0 : if (tevent_req_nomem(subreq, req)) {
25449 0 : return tevent_req_post(req, ev);
25450 : }
25451 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetServiceAccountPassword_done, req);
25452 0 : return req;
25453 : }
25454 :
25455 0 : static void dcerpc_clusapi_SetServiceAccountPassword_done(struct tevent_req *subreq)
25456 : {
25457 0 : struct tevent_req *req = tevent_req_callback_data(
25458 : subreq, struct tevent_req);
25459 0 : struct dcerpc_clusapi_SetServiceAccountPassword_state *state = tevent_req_data(
25460 : req, struct dcerpc_clusapi_SetServiceAccountPassword_state);
25461 : NTSTATUS status;
25462 : TALLOC_CTX *mem_ctx;
25463 :
25464 0 : if (state->out_mem_ctx) {
25465 0 : mem_ctx = state->out_mem_ctx;
25466 : } else {
25467 0 : mem_ctx = state;
25468 : }
25469 :
25470 0 : status = dcerpc_clusapi_SetServiceAccountPassword_r_recv(subreq, mem_ctx);
25471 0 : TALLOC_FREE(subreq);
25472 0 : if (tevent_req_nterror(req, status)) {
25473 0 : return;
25474 : }
25475 :
25476 : /* Copy out parameters */
25477 : {
25478 : size_t _copy_len_ReturnStatusBufferPtr;
25479 0 : if ((*state->tmp.out.SizeReturned) > (state->tmp.in.ReturnStatusBufferSize)) {
25480 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
25481 0 : return;
25482 : }
25483 0 : _copy_len_ReturnStatusBufferPtr = *state->tmp.out.SizeReturned;
25484 0 : if (state->orig.out.ReturnStatusBufferPtr != state->tmp.out.ReturnStatusBufferPtr) {
25485 0 : memcpy(state->orig.out.ReturnStatusBufferPtr, state->tmp.out.ReturnStatusBufferPtr, _copy_len_ReturnStatusBufferPtr * sizeof(*state->orig.out.ReturnStatusBufferPtr));
25486 : }
25487 : }
25488 0 : *state->orig.out.SizeReturned = *state->tmp.out.SizeReturned;
25489 0 : *state->orig.out.ExpectedBufferSize = *state->tmp.out.ExpectedBufferSize;
25490 :
25491 : /* Copy result */
25492 0 : state->orig.out.result = state->tmp.out.result;
25493 :
25494 : /* Reset temporary structure */
25495 0 : NDR_ZERO_STRUCT(state->tmp);
25496 :
25497 0 : tevent_req_done(req);
25498 : }
25499 :
25500 0 : NTSTATUS dcerpc_clusapi_SetServiceAccountPassword_recv(struct tevent_req *req,
25501 : TALLOC_CTX *mem_ctx,
25502 : WERROR *result)
25503 : {
25504 0 : struct dcerpc_clusapi_SetServiceAccountPassword_state *state = tevent_req_data(
25505 : req, struct dcerpc_clusapi_SetServiceAccountPassword_state);
25506 : NTSTATUS status;
25507 :
25508 0 : if (tevent_req_is_nterror(req, &status)) {
25509 0 : tevent_req_received(req);
25510 0 : return status;
25511 : }
25512 :
25513 : /* Steal possible out parameters to the callers context */
25514 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25515 :
25516 : /* Return result */
25517 0 : *result = state->orig.out.result;
25518 :
25519 0 : tevent_req_received(req);
25520 0 : return NT_STATUS_OK;
25521 : }
25522 :
25523 0 : NTSTATUS dcerpc_clusapi_SetServiceAccountPassword(struct dcerpc_binding_handle *h,
25524 : TALLOC_CTX *mem_ctx,
25525 : const char *_lpszNewPassword /* [in] [charset(UTF16),ref] */,
25526 : enum IDL_CLUSTER_SET_PASSWORD_FLAGS _dwFlags /* [in] */,
25527 : struct IDL_CLUSTER_SET_PASSWORD_STATUS *_ReturnStatusBufferPtr /* [out] [length_is(*SizeReturned),size_is(ReturnStatusBufferSize)] */,
25528 : uint32_t _ReturnStatusBufferSize /* [in] [range(0,(64*1024))] */,
25529 : uint32_t *_SizeReturned /* [out] [ref] */,
25530 : uint32_t *_ExpectedBufferSize /* [out] [ref] */,
25531 : WERROR *result)
25532 : {
25533 : struct clusapi_SetServiceAccountPassword r;
25534 : NTSTATUS status;
25535 :
25536 : /* In parameters */
25537 0 : r.in.lpszNewPassword = _lpszNewPassword;
25538 0 : r.in.dwFlags = _dwFlags;
25539 0 : r.in.ReturnStatusBufferSize = _ReturnStatusBufferSize;
25540 :
25541 : /* Out parameters */
25542 0 : r.out.ReturnStatusBufferPtr = _ReturnStatusBufferPtr;
25543 0 : r.out.SizeReturned = _SizeReturned;
25544 0 : r.out.ExpectedBufferSize = _ExpectedBufferSize;
25545 :
25546 : /* Result */
25547 0 : NDR_ZERO_STRUCT(r.out.result);
25548 :
25549 0 : status = dcerpc_clusapi_SetServiceAccountPassword_r(h, mem_ctx, &r);
25550 0 : if (!NT_STATUS_IS_OK(status)) {
25551 0 : return status;
25552 : }
25553 :
25554 : /* Return variables */
25555 : {
25556 : size_t _copy_len_ReturnStatusBufferPtr;
25557 0 : if ((*r.out.SizeReturned) > (r.in.ReturnStatusBufferSize)) {
25558 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
25559 : }
25560 0 : _copy_len_ReturnStatusBufferPtr = *r.out.SizeReturned;
25561 0 : if (_ReturnStatusBufferPtr != r.out.ReturnStatusBufferPtr) {
25562 0 : memcpy(_ReturnStatusBufferPtr, r.out.ReturnStatusBufferPtr, _copy_len_ReturnStatusBufferPtr * sizeof(*_ReturnStatusBufferPtr));
25563 : }
25564 : }
25565 0 : *_SizeReturned = *r.out.SizeReturned;
25566 0 : *_ExpectedBufferSize = *r.out.ExpectedBufferSize;
25567 :
25568 : /* Return result */
25569 0 : *result = r.out.result;
25570 :
25571 0 : return NT_STATUS_OK;
25572 : }
25573 :
25574 : struct dcerpc_clusapi_SetResourceDependencyExpression_r_state {
25575 : TALLOC_CTX *out_mem_ctx;
25576 : };
25577 :
25578 : static void dcerpc_clusapi_SetResourceDependencyExpression_r_done(struct tevent_req *subreq);
25579 :
25580 0 : struct tevent_req *dcerpc_clusapi_SetResourceDependencyExpression_r_send(TALLOC_CTX *mem_ctx,
25581 : struct tevent_context *ev,
25582 : struct dcerpc_binding_handle *h,
25583 : struct clusapi_SetResourceDependencyExpression *r)
25584 : {
25585 : struct tevent_req *req;
25586 : struct dcerpc_clusapi_SetResourceDependencyExpression_r_state *state;
25587 : struct tevent_req *subreq;
25588 :
25589 0 : req = tevent_req_create(mem_ctx, &state,
25590 : struct dcerpc_clusapi_SetResourceDependencyExpression_r_state);
25591 0 : if (req == NULL) {
25592 0 : return NULL;
25593 : }
25594 :
25595 0 : state->out_mem_ctx = talloc_new(state);
25596 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25597 0 : return tevent_req_post(req, ev);
25598 : }
25599 :
25600 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
25601 : NULL, &ndr_table_clusapi,
25602 0 : NDR_CLUSAPI_SETRESOURCEDEPENDENCYEXPRESSION, state->out_mem_ctx, r);
25603 0 : if (tevent_req_nomem(subreq, req)) {
25604 0 : return tevent_req_post(req, ev);
25605 : }
25606 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetResourceDependencyExpression_r_done, req);
25607 :
25608 0 : return req;
25609 : }
25610 :
25611 0 : static void dcerpc_clusapi_SetResourceDependencyExpression_r_done(struct tevent_req *subreq)
25612 : {
25613 0 : struct tevent_req *req =
25614 0 : tevent_req_callback_data(subreq,
25615 : struct tevent_req);
25616 : NTSTATUS status;
25617 :
25618 0 : status = dcerpc_binding_handle_call_recv(subreq);
25619 0 : TALLOC_FREE(subreq);
25620 0 : if (tevent_req_nterror(req, status)) {
25621 0 : return;
25622 : }
25623 :
25624 0 : tevent_req_done(req);
25625 : }
25626 :
25627 0 : NTSTATUS dcerpc_clusapi_SetResourceDependencyExpression_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
25628 : {
25629 0 : struct dcerpc_clusapi_SetResourceDependencyExpression_r_state *state =
25630 0 : tevent_req_data(req,
25631 : struct dcerpc_clusapi_SetResourceDependencyExpression_r_state);
25632 : NTSTATUS status;
25633 :
25634 0 : if (tevent_req_is_nterror(req, &status)) {
25635 0 : tevent_req_received(req);
25636 0 : return status;
25637 : }
25638 :
25639 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25640 :
25641 0 : tevent_req_received(req);
25642 0 : return NT_STATUS_OK;
25643 : }
25644 :
25645 0 : NTSTATUS dcerpc_clusapi_SetResourceDependencyExpression_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetResourceDependencyExpression *r)
25646 : {
25647 : NTSTATUS status;
25648 :
25649 0 : status = dcerpc_binding_handle_call(h,
25650 : NULL, &ndr_table_clusapi,
25651 : NDR_CLUSAPI_SETRESOURCEDEPENDENCYEXPRESSION, mem_ctx, r);
25652 :
25653 0 : return status;
25654 : }
25655 :
25656 : struct dcerpc_clusapi_SetResourceDependencyExpression_state {
25657 : struct clusapi_SetResourceDependencyExpression orig;
25658 : struct clusapi_SetResourceDependencyExpression tmp;
25659 : TALLOC_CTX *out_mem_ctx;
25660 : };
25661 :
25662 : static void dcerpc_clusapi_SetResourceDependencyExpression_done(struct tevent_req *subreq);
25663 :
25664 0 : struct tevent_req *dcerpc_clusapi_SetResourceDependencyExpression_send(TALLOC_CTX *mem_ctx,
25665 : struct tevent_context *ev,
25666 : struct dcerpc_binding_handle *h,
25667 : struct policy_handle _hResource /* [in] */,
25668 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),unique] */,
25669 : WERROR *_rpc_status /* [out] [ref] */)
25670 : {
25671 : struct tevent_req *req;
25672 : struct dcerpc_clusapi_SetResourceDependencyExpression_state *state;
25673 : struct tevent_req *subreq;
25674 :
25675 0 : req = tevent_req_create(mem_ctx, &state,
25676 : struct dcerpc_clusapi_SetResourceDependencyExpression_state);
25677 0 : if (req == NULL) {
25678 0 : return NULL;
25679 : }
25680 0 : state->out_mem_ctx = NULL;
25681 :
25682 : /* In parameters */
25683 0 : state->orig.in.hResource = _hResource;
25684 0 : state->orig.in.lpszDependencyExpression = _lpszDependencyExpression;
25685 :
25686 : /* Out parameters */
25687 0 : state->orig.out.rpc_status = _rpc_status;
25688 :
25689 : /* Result */
25690 0 : NDR_ZERO_STRUCT(state->orig.out.result);
25691 :
25692 0 : state->out_mem_ctx = talloc_named_const(state, 0,
25693 : "dcerpc_clusapi_SetResourceDependencyExpression_out_memory");
25694 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25695 0 : return tevent_req_post(req, ev);
25696 : }
25697 :
25698 : /* make a temporary copy, that we pass to the dispatch function */
25699 0 : state->tmp = state->orig;
25700 :
25701 0 : subreq = dcerpc_clusapi_SetResourceDependencyExpression_r_send(state, ev, h, &state->tmp);
25702 0 : if (tevent_req_nomem(subreq, req)) {
25703 0 : return tevent_req_post(req, ev);
25704 : }
25705 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetResourceDependencyExpression_done, req);
25706 0 : return req;
25707 : }
25708 :
25709 0 : static void dcerpc_clusapi_SetResourceDependencyExpression_done(struct tevent_req *subreq)
25710 : {
25711 0 : struct tevent_req *req = tevent_req_callback_data(
25712 : subreq, struct tevent_req);
25713 0 : struct dcerpc_clusapi_SetResourceDependencyExpression_state *state = tevent_req_data(
25714 : req, struct dcerpc_clusapi_SetResourceDependencyExpression_state);
25715 : NTSTATUS status;
25716 : TALLOC_CTX *mem_ctx;
25717 :
25718 0 : if (state->out_mem_ctx) {
25719 0 : mem_ctx = state->out_mem_ctx;
25720 : } else {
25721 0 : mem_ctx = state;
25722 : }
25723 :
25724 0 : status = dcerpc_clusapi_SetResourceDependencyExpression_r_recv(subreq, mem_ctx);
25725 0 : TALLOC_FREE(subreq);
25726 0 : if (tevent_req_nterror(req, status)) {
25727 0 : return;
25728 : }
25729 :
25730 : /* Copy out parameters */
25731 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
25732 :
25733 : /* Copy result */
25734 0 : state->orig.out.result = state->tmp.out.result;
25735 :
25736 : /* Reset temporary structure */
25737 0 : NDR_ZERO_STRUCT(state->tmp);
25738 :
25739 0 : tevent_req_done(req);
25740 : }
25741 :
25742 0 : NTSTATUS dcerpc_clusapi_SetResourceDependencyExpression_recv(struct tevent_req *req,
25743 : TALLOC_CTX *mem_ctx,
25744 : WERROR *result)
25745 : {
25746 0 : struct dcerpc_clusapi_SetResourceDependencyExpression_state *state = tevent_req_data(
25747 : req, struct dcerpc_clusapi_SetResourceDependencyExpression_state);
25748 : NTSTATUS status;
25749 :
25750 0 : if (tevent_req_is_nterror(req, &status)) {
25751 0 : tevent_req_received(req);
25752 0 : return status;
25753 : }
25754 :
25755 : /* Steal possible out parameters to the callers context */
25756 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25757 :
25758 : /* Return result */
25759 0 : *result = state->orig.out.result;
25760 :
25761 0 : tevent_req_received(req);
25762 0 : return NT_STATUS_OK;
25763 : }
25764 :
25765 0 : NTSTATUS dcerpc_clusapi_SetResourceDependencyExpression(struct dcerpc_binding_handle *h,
25766 : TALLOC_CTX *mem_ctx,
25767 : struct policy_handle _hResource /* [in] */,
25768 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),unique] */,
25769 : WERROR *_rpc_status /* [out] [ref] */,
25770 : WERROR *result)
25771 : {
25772 : struct clusapi_SetResourceDependencyExpression r;
25773 : NTSTATUS status;
25774 :
25775 : /* In parameters */
25776 0 : r.in.hResource = _hResource;
25777 0 : r.in.lpszDependencyExpression = _lpszDependencyExpression;
25778 :
25779 : /* Out parameters */
25780 0 : r.out.rpc_status = _rpc_status;
25781 :
25782 : /* Result */
25783 0 : NDR_ZERO_STRUCT(r.out.result);
25784 :
25785 0 : status = dcerpc_clusapi_SetResourceDependencyExpression_r(h, mem_ctx, &r);
25786 0 : if (!NT_STATUS_IS_OK(status)) {
25787 0 : return status;
25788 : }
25789 :
25790 : /* Return variables */
25791 0 : *_rpc_status = *r.out.rpc_status;
25792 :
25793 : /* Return result */
25794 0 : *result = r.out.result;
25795 :
25796 0 : return NT_STATUS_OK;
25797 : }
25798 :
25799 : struct dcerpc_clusapi_GetResourceDependencyExpression_r_state {
25800 : TALLOC_CTX *out_mem_ctx;
25801 : };
25802 :
25803 : static void dcerpc_clusapi_GetResourceDependencyExpression_r_done(struct tevent_req *subreq);
25804 :
25805 0 : struct tevent_req *dcerpc_clusapi_GetResourceDependencyExpression_r_send(TALLOC_CTX *mem_ctx,
25806 : struct tevent_context *ev,
25807 : struct dcerpc_binding_handle *h,
25808 : struct clusapi_GetResourceDependencyExpression *r)
25809 : {
25810 : struct tevent_req *req;
25811 : struct dcerpc_clusapi_GetResourceDependencyExpression_r_state *state;
25812 : struct tevent_req *subreq;
25813 :
25814 0 : req = tevent_req_create(mem_ctx, &state,
25815 : struct dcerpc_clusapi_GetResourceDependencyExpression_r_state);
25816 0 : if (req == NULL) {
25817 0 : return NULL;
25818 : }
25819 :
25820 0 : state->out_mem_ctx = talloc_new(state);
25821 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25822 0 : return tevent_req_post(req, ev);
25823 : }
25824 :
25825 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
25826 : NULL, &ndr_table_clusapi,
25827 0 : NDR_CLUSAPI_GETRESOURCEDEPENDENCYEXPRESSION, state->out_mem_ctx, r);
25828 0 : if (tevent_req_nomem(subreq, req)) {
25829 0 : return tevent_req_post(req, ev);
25830 : }
25831 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceDependencyExpression_r_done, req);
25832 :
25833 0 : return req;
25834 : }
25835 :
25836 0 : static void dcerpc_clusapi_GetResourceDependencyExpression_r_done(struct tevent_req *subreq)
25837 : {
25838 0 : struct tevent_req *req =
25839 0 : tevent_req_callback_data(subreq,
25840 : struct tevent_req);
25841 : NTSTATUS status;
25842 :
25843 0 : status = dcerpc_binding_handle_call_recv(subreq);
25844 0 : TALLOC_FREE(subreq);
25845 0 : if (tevent_req_nterror(req, status)) {
25846 0 : return;
25847 : }
25848 :
25849 0 : tevent_req_done(req);
25850 : }
25851 :
25852 0 : NTSTATUS dcerpc_clusapi_GetResourceDependencyExpression_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
25853 : {
25854 0 : struct dcerpc_clusapi_GetResourceDependencyExpression_r_state *state =
25855 0 : tevent_req_data(req,
25856 : struct dcerpc_clusapi_GetResourceDependencyExpression_r_state);
25857 : NTSTATUS status;
25858 :
25859 0 : if (tevent_req_is_nterror(req, &status)) {
25860 0 : tevent_req_received(req);
25861 0 : return status;
25862 : }
25863 :
25864 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25865 :
25866 0 : tevent_req_received(req);
25867 0 : return NT_STATUS_OK;
25868 : }
25869 :
25870 0 : NTSTATUS dcerpc_clusapi_GetResourceDependencyExpression_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetResourceDependencyExpression *r)
25871 : {
25872 : NTSTATUS status;
25873 :
25874 0 : status = dcerpc_binding_handle_call(h,
25875 : NULL, &ndr_table_clusapi,
25876 : NDR_CLUSAPI_GETRESOURCEDEPENDENCYEXPRESSION, mem_ctx, r);
25877 :
25878 0 : return status;
25879 : }
25880 :
25881 : struct dcerpc_clusapi_GetResourceDependencyExpression_state {
25882 : struct clusapi_GetResourceDependencyExpression orig;
25883 : struct clusapi_GetResourceDependencyExpression tmp;
25884 : TALLOC_CTX *out_mem_ctx;
25885 : };
25886 :
25887 : static void dcerpc_clusapi_GetResourceDependencyExpression_done(struct tevent_req *subreq);
25888 :
25889 0 : struct tevent_req *dcerpc_clusapi_GetResourceDependencyExpression_send(TALLOC_CTX *mem_ctx,
25890 : struct tevent_context *ev,
25891 : struct dcerpc_binding_handle *h,
25892 : struct policy_handle _hResource /* [in] */,
25893 : const char **_lpszDependencyExpression /* [out] [charset(UTF16),ref] */,
25894 : WERROR *_rpc_status /* [out] [ref] */)
25895 : {
25896 : struct tevent_req *req;
25897 : struct dcerpc_clusapi_GetResourceDependencyExpression_state *state;
25898 : struct tevent_req *subreq;
25899 :
25900 0 : req = tevent_req_create(mem_ctx, &state,
25901 : struct dcerpc_clusapi_GetResourceDependencyExpression_state);
25902 0 : if (req == NULL) {
25903 0 : return NULL;
25904 : }
25905 0 : state->out_mem_ctx = NULL;
25906 :
25907 : /* In parameters */
25908 0 : state->orig.in.hResource = _hResource;
25909 :
25910 : /* Out parameters */
25911 0 : state->orig.out.lpszDependencyExpression = _lpszDependencyExpression;
25912 0 : state->orig.out.rpc_status = _rpc_status;
25913 :
25914 : /* Result */
25915 0 : NDR_ZERO_STRUCT(state->orig.out.result);
25916 :
25917 0 : state->out_mem_ctx = talloc_named_const(state, 0,
25918 : "dcerpc_clusapi_GetResourceDependencyExpression_out_memory");
25919 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
25920 0 : return tevent_req_post(req, ev);
25921 : }
25922 :
25923 : /* make a temporary copy, that we pass to the dispatch function */
25924 0 : state->tmp = state->orig;
25925 :
25926 0 : subreq = dcerpc_clusapi_GetResourceDependencyExpression_r_send(state, ev, h, &state->tmp);
25927 0 : if (tevent_req_nomem(subreq, req)) {
25928 0 : return tevent_req_post(req, ev);
25929 : }
25930 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceDependencyExpression_done, req);
25931 0 : return req;
25932 : }
25933 :
25934 0 : static void dcerpc_clusapi_GetResourceDependencyExpression_done(struct tevent_req *subreq)
25935 : {
25936 0 : struct tevent_req *req = tevent_req_callback_data(
25937 : subreq, struct tevent_req);
25938 0 : struct dcerpc_clusapi_GetResourceDependencyExpression_state *state = tevent_req_data(
25939 : req, struct dcerpc_clusapi_GetResourceDependencyExpression_state);
25940 : NTSTATUS status;
25941 : TALLOC_CTX *mem_ctx;
25942 :
25943 0 : if (state->out_mem_ctx) {
25944 0 : mem_ctx = state->out_mem_ctx;
25945 : } else {
25946 0 : mem_ctx = state;
25947 : }
25948 :
25949 0 : status = dcerpc_clusapi_GetResourceDependencyExpression_r_recv(subreq, mem_ctx);
25950 0 : TALLOC_FREE(subreq);
25951 0 : if (tevent_req_nterror(req, status)) {
25952 0 : return;
25953 : }
25954 :
25955 : /* Copy out parameters */
25956 0 : *state->orig.out.lpszDependencyExpression = *state->tmp.out.lpszDependencyExpression;
25957 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
25958 :
25959 : /* Copy result */
25960 0 : state->orig.out.result = state->tmp.out.result;
25961 :
25962 : /* Reset temporary structure */
25963 0 : NDR_ZERO_STRUCT(state->tmp);
25964 :
25965 0 : tevent_req_done(req);
25966 : }
25967 :
25968 0 : NTSTATUS dcerpc_clusapi_GetResourceDependencyExpression_recv(struct tevent_req *req,
25969 : TALLOC_CTX *mem_ctx,
25970 : WERROR *result)
25971 : {
25972 0 : struct dcerpc_clusapi_GetResourceDependencyExpression_state *state = tevent_req_data(
25973 : req, struct dcerpc_clusapi_GetResourceDependencyExpression_state);
25974 : NTSTATUS status;
25975 :
25976 0 : if (tevent_req_is_nterror(req, &status)) {
25977 0 : tevent_req_received(req);
25978 0 : return status;
25979 : }
25980 :
25981 : /* Steal possible out parameters to the callers context */
25982 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
25983 :
25984 : /* Return result */
25985 0 : *result = state->orig.out.result;
25986 :
25987 0 : tevent_req_received(req);
25988 0 : return NT_STATUS_OK;
25989 : }
25990 :
25991 0 : NTSTATUS dcerpc_clusapi_GetResourceDependencyExpression(struct dcerpc_binding_handle *h,
25992 : TALLOC_CTX *mem_ctx,
25993 : struct policy_handle _hResource /* [in] */,
25994 : const char **_lpszDependencyExpression /* [out] [charset(UTF16),ref] */,
25995 : WERROR *_rpc_status /* [out] [ref] */,
25996 : WERROR *result)
25997 : {
25998 : struct clusapi_GetResourceDependencyExpression r;
25999 : NTSTATUS status;
26000 :
26001 : /* In parameters */
26002 0 : r.in.hResource = _hResource;
26003 :
26004 : /* Out parameters */
26005 0 : r.out.lpszDependencyExpression = _lpszDependencyExpression;
26006 0 : r.out.rpc_status = _rpc_status;
26007 :
26008 : /* Result */
26009 0 : NDR_ZERO_STRUCT(r.out.result);
26010 :
26011 0 : status = dcerpc_clusapi_GetResourceDependencyExpression_r(h, mem_ctx, &r);
26012 0 : if (!NT_STATUS_IS_OK(status)) {
26013 0 : return status;
26014 : }
26015 :
26016 : /* Return variables */
26017 0 : *_lpszDependencyExpression = *r.out.lpszDependencyExpression;
26018 0 : *_rpc_status = *r.out.rpc_status;
26019 :
26020 : /* Return result */
26021 0 : *result = r.out.result;
26022 :
26023 0 : return NT_STATUS_OK;
26024 : }
26025 :
26026 : struct dcerpc_Opnum111NotUsedOnWire_r_state {
26027 : TALLOC_CTX *out_mem_ctx;
26028 : };
26029 :
26030 : static void dcerpc_Opnum111NotUsedOnWire_r_done(struct tevent_req *subreq);
26031 :
26032 0 : struct tevent_req *dcerpc_Opnum111NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
26033 : struct tevent_context *ev,
26034 : struct dcerpc_binding_handle *h,
26035 : struct Opnum111NotUsedOnWire *r)
26036 : {
26037 : struct tevent_req *req;
26038 : struct dcerpc_Opnum111NotUsedOnWire_r_state *state;
26039 : struct tevent_req *subreq;
26040 :
26041 0 : req = tevent_req_create(mem_ctx, &state,
26042 : struct dcerpc_Opnum111NotUsedOnWire_r_state);
26043 0 : if (req == NULL) {
26044 0 : return NULL;
26045 : }
26046 :
26047 0 : state->out_mem_ctx = NULL;
26048 :
26049 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
26050 : NULL, &ndr_table_clusapi,
26051 : NDR_OPNUM111NOTUSEDONWIRE, state, r);
26052 0 : if (tevent_req_nomem(subreq, req)) {
26053 0 : return tevent_req_post(req, ev);
26054 : }
26055 0 : tevent_req_set_callback(subreq, dcerpc_Opnum111NotUsedOnWire_r_done, req);
26056 :
26057 0 : return req;
26058 : }
26059 :
26060 0 : static void dcerpc_Opnum111NotUsedOnWire_r_done(struct tevent_req *subreq)
26061 : {
26062 0 : struct tevent_req *req =
26063 0 : tevent_req_callback_data(subreq,
26064 : struct tevent_req);
26065 : NTSTATUS status;
26066 :
26067 0 : status = dcerpc_binding_handle_call_recv(subreq);
26068 0 : TALLOC_FREE(subreq);
26069 0 : if (tevent_req_nterror(req, status)) {
26070 0 : return;
26071 : }
26072 :
26073 0 : tevent_req_done(req);
26074 : }
26075 :
26076 0 : NTSTATUS dcerpc_Opnum111NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
26077 : {
26078 0 : struct dcerpc_Opnum111NotUsedOnWire_r_state *state =
26079 0 : tevent_req_data(req,
26080 : struct dcerpc_Opnum111NotUsedOnWire_r_state);
26081 : NTSTATUS status;
26082 :
26083 0 : if (tevent_req_is_nterror(req, &status)) {
26084 0 : tevent_req_received(req);
26085 0 : return status;
26086 : }
26087 :
26088 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26089 :
26090 0 : tevent_req_received(req);
26091 0 : return NT_STATUS_OK;
26092 : }
26093 :
26094 0 : NTSTATUS dcerpc_Opnum111NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum111NotUsedOnWire *r)
26095 : {
26096 : NTSTATUS status;
26097 :
26098 0 : status = dcerpc_binding_handle_call(h,
26099 : NULL, &ndr_table_clusapi,
26100 : NDR_OPNUM111NOTUSEDONWIRE, mem_ctx, r);
26101 :
26102 0 : return status;
26103 : }
26104 :
26105 : struct dcerpc_Opnum111NotUsedOnWire_state {
26106 : struct Opnum111NotUsedOnWire orig;
26107 : struct Opnum111NotUsedOnWire tmp;
26108 : TALLOC_CTX *out_mem_ctx;
26109 : };
26110 :
26111 : static void dcerpc_Opnum111NotUsedOnWire_done(struct tevent_req *subreq);
26112 :
26113 0 : struct tevent_req *dcerpc_Opnum111NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
26114 : struct tevent_context *ev,
26115 : struct dcerpc_binding_handle *h)
26116 : {
26117 : struct tevent_req *req;
26118 : struct dcerpc_Opnum111NotUsedOnWire_state *state;
26119 : struct tevent_req *subreq;
26120 :
26121 0 : req = tevent_req_create(mem_ctx, &state,
26122 : struct dcerpc_Opnum111NotUsedOnWire_state);
26123 0 : if (req == NULL) {
26124 0 : return NULL;
26125 : }
26126 0 : state->out_mem_ctx = NULL;
26127 :
26128 : /* In parameters */
26129 :
26130 : /* Out parameters */
26131 :
26132 : /* Result */
26133 0 : NDR_ZERO_STRUCT(state->orig.out.result);
26134 :
26135 : /* make a temporary copy, that we pass to the dispatch function */
26136 0 : state->tmp = state->orig;
26137 :
26138 0 : subreq = dcerpc_Opnum111NotUsedOnWire_r_send(state, ev, h, &state->tmp);
26139 0 : if (tevent_req_nomem(subreq, req)) {
26140 0 : return tevent_req_post(req, ev);
26141 : }
26142 0 : tevent_req_set_callback(subreq, dcerpc_Opnum111NotUsedOnWire_done, req);
26143 0 : return req;
26144 : }
26145 :
26146 0 : static void dcerpc_Opnum111NotUsedOnWire_done(struct tevent_req *subreq)
26147 : {
26148 0 : struct tevent_req *req = tevent_req_callback_data(
26149 : subreq, struct tevent_req);
26150 0 : struct dcerpc_Opnum111NotUsedOnWire_state *state = tevent_req_data(
26151 : req, struct dcerpc_Opnum111NotUsedOnWire_state);
26152 : NTSTATUS status;
26153 : TALLOC_CTX *mem_ctx;
26154 :
26155 0 : if (state->out_mem_ctx) {
26156 0 : mem_ctx = state->out_mem_ctx;
26157 : } else {
26158 0 : mem_ctx = state;
26159 : }
26160 :
26161 0 : status = dcerpc_Opnum111NotUsedOnWire_r_recv(subreq, mem_ctx);
26162 0 : TALLOC_FREE(subreq);
26163 0 : if (tevent_req_nterror(req, status)) {
26164 0 : return;
26165 : }
26166 :
26167 : /* Copy out parameters */
26168 :
26169 : /* Copy result */
26170 0 : state->orig.out.result = state->tmp.out.result;
26171 :
26172 : /* Reset temporary structure */
26173 0 : NDR_ZERO_STRUCT(state->tmp);
26174 :
26175 0 : tevent_req_done(req);
26176 : }
26177 :
26178 0 : NTSTATUS dcerpc_Opnum111NotUsedOnWire_recv(struct tevent_req *req,
26179 : TALLOC_CTX *mem_ctx,
26180 : WERROR *result)
26181 : {
26182 0 : struct dcerpc_Opnum111NotUsedOnWire_state *state = tevent_req_data(
26183 : req, struct dcerpc_Opnum111NotUsedOnWire_state);
26184 : NTSTATUS status;
26185 :
26186 0 : if (tevent_req_is_nterror(req, &status)) {
26187 0 : tevent_req_received(req);
26188 0 : return status;
26189 : }
26190 :
26191 : /* Steal possible out parameters to the callers context */
26192 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26193 :
26194 : /* Return result */
26195 0 : *result = state->orig.out.result;
26196 :
26197 0 : tevent_req_received(req);
26198 0 : return NT_STATUS_OK;
26199 : }
26200 :
26201 0 : NTSTATUS dcerpc_Opnum111NotUsedOnWire(struct dcerpc_binding_handle *h,
26202 : TALLOC_CTX *mem_ctx,
26203 : WERROR *result)
26204 : {
26205 : struct Opnum111NotUsedOnWire r;
26206 : NTSTATUS status;
26207 :
26208 : /* In parameters */
26209 :
26210 : /* Out parameters */
26211 :
26212 : /* Result */
26213 0 : NDR_ZERO_STRUCT(r.out.result);
26214 :
26215 0 : status = dcerpc_Opnum111NotUsedOnWire_r(h, mem_ctx, &r);
26216 0 : if (!NT_STATUS_IS_OK(status)) {
26217 0 : return status;
26218 : }
26219 :
26220 : /* Return variables */
26221 :
26222 : /* Return result */
26223 0 : *result = r.out.result;
26224 :
26225 0 : return NT_STATUS_OK;
26226 : }
26227 :
26228 : struct dcerpc_clusapi_GetResourceNetworkName_r_state {
26229 : TALLOC_CTX *out_mem_ctx;
26230 : };
26231 :
26232 : static void dcerpc_clusapi_GetResourceNetworkName_r_done(struct tevent_req *subreq);
26233 :
26234 0 : struct tevent_req *dcerpc_clusapi_GetResourceNetworkName_r_send(TALLOC_CTX *mem_ctx,
26235 : struct tevent_context *ev,
26236 : struct dcerpc_binding_handle *h,
26237 : struct clusapi_GetResourceNetworkName *r)
26238 : {
26239 : struct tevent_req *req;
26240 : struct dcerpc_clusapi_GetResourceNetworkName_r_state *state;
26241 : struct tevent_req *subreq;
26242 :
26243 0 : req = tevent_req_create(mem_ctx, &state,
26244 : struct dcerpc_clusapi_GetResourceNetworkName_r_state);
26245 0 : if (req == NULL) {
26246 0 : return NULL;
26247 : }
26248 :
26249 0 : state->out_mem_ctx = talloc_new(state);
26250 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26251 0 : return tevent_req_post(req, ev);
26252 : }
26253 :
26254 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
26255 : NULL, &ndr_table_clusapi,
26256 0 : NDR_CLUSAPI_GETRESOURCENETWORKNAME, state->out_mem_ctx, r);
26257 0 : if (tevent_req_nomem(subreq, req)) {
26258 0 : return tevent_req_post(req, ev);
26259 : }
26260 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceNetworkName_r_done, req);
26261 :
26262 0 : return req;
26263 : }
26264 :
26265 0 : static void dcerpc_clusapi_GetResourceNetworkName_r_done(struct tevent_req *subreq)
26266 : {
26267 0 : struct tevent_req *req =
26268 0 : tevent_req_callback_data(subreq,
26269 : struct tevent_req);
26270 : NTSTATUS status;
26271 :
26272 0 : status = dcerpc_binding_handle_call_recv(subreq);
26273 0 : TALLOC_FREE(subreq);
26274 0 : if (tevent_req_nterror(req, status)) {
26275 0 : return;
26276 : }
26277 :
26278 0 : tevent_req_done(req);
26279 : }
26280 :
26281 0 : NTSTATUS dcerpc_clusapi_GetResourceNetworkName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
26282 : {
26283 0 : struct dcerpc_clusapi_GetResourceNetworkName_r_state *state =
26284 0 : tevent_req_data(req,
26285 : struct dcerpc_clusapi_GetResourceNetworkName_r_state);
26286 : NTSTATUS status;
26287 :
26288 0 : if (tevent_req_is_nterror(req, &status)) {
26289 0 : tevent_req_received(req);
26290 0 : return status;
26291 : }
26292 :
26293 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26294 :
26295 0 : tevent_req_received(req);
26296 0 : return NT_STATUS_OK;
26297 : }
26298 :
26299 0 : NTSTATUS dcerpc_clusapi_GetResourceNetworkName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetResourceNetworkName *r)
26300 : {
26301 : NTSTATUS status;
26302 :
26303 0 : status = dcerpc_binding_handle_call(h,
26304 : NULL, &ndr_table_clusapi,
26305 : NDR_CLUSAPI_GETRESOURCENETWORKNAME, mem_ctx, r);
26306 :
26307 0 : return status;
26308 : }
26309 :
26310 : struct dcerpc_clusapi_GetResourceNetworkName_state {
26311 : struct clusapi_GetResourceNetworkName orig;
26312 : struct clusapi_GetResourceNetworkName tmp;
26313 : TALLOC_CTX *out_mem_ctx;
26314 : };
26315 :
26316 : static void dcerpc_clusapi_GetResourceNetworkName_done(struct tevent_req *subreq);
26317 :
26318 0 : struct tevent_req *dcerpc_clusapi_GetResourceNetworkName_send(TALLOC_CTX *mem_ctx,
26319 : struct tevent_context *ev,
26320 : struct dcerpc_binding_handle *h,
26321 : struct policy_handle _hResource /* [in] */,
26322 : const char **_lpszName /* [out] [charset(UTF16),ref] */,
26323 : WERROR *_rpc_status /* [out] [ref] */)
26324 : {
26325 : struct tevent_req *req;
26326 : struct dcerpc_clusapi_GetResourceNetworkName_state *state;
26327 : struct tevent_req *subreq;
26328 :
26329 0 : req = tevent_req_create(mem_ctx, &state,
26330 : struct dcerpc_clusapi_GetResourceNetworkName_state);
26331 0 : if (req == NULL) {
26332 0 : return NULL;
26333 : }
26334 0 : state->out_mem_ctx = NULL;
26335 :
26336 : /* In parameters */
26337 0 : state->orig.in.hResource = _hResource;
26338 :
26339 : /* Out parameters */
26340 0 : state->orig.out.lpszName = _lpszName;
26341 0 : state->orig.out.rpc_status = _rpc_status;
26342 :
26343 : /* Result */
26344 0 : NDR_ZERO_STRUCT(state->orig.out.result);
26345 :
26346 0 : state->out_mem_ctx = talloc_named_const(state, 0,
26347 : "dcerpc_clusapi_GetResourceNetworkName_out_memory");
26348 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26349 0 : return tevent_req_post(req, ev);
26350 : }
26351 :
26352 : /* make a temporary copy, that we pass to the dispatch function */
26353 0 : state->tmp = state->orig;
26354 :
26355 0 : subreq = dcerpc_clusapi_GetResourceNetworkName_r_send(state, ev, h, &state->tmp);
26356 0 : if (tevent_req_nomem(subreq, req)) {
26357 0 : return tevent_req_post(req, ev);
26358 : }
26359 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetResourceNetworkName_done, req);
26360 0 : return req;
26361 : }
26362 :
26363 0 : static void dcerpc_clusapi_GetResourceNetworkName_done(struct tevent_req *subreq)
26364 : {
26365 0 : struct tevent_req *req = tevent_req_callback_data(
26366 : subreq, struct tevent_req);
26367 0 : struct dcerpc_clusapi_GetResourceNetworkName_state *state = tevent_req_data(
26368 : req, struct dcerpc_clusapi_GetResourceNetworkName_state);
26369 : NTSTATUS status;
26370 : TALLOC_CTX *mem_ctx;
26371 :
26372 0 : if (state->out_mem_ctx) {
26373 0 : mem_ctx = state->out_mem_ctx;
26374 : } else {
26375 0 : mem_ctx = state;
26376 : }
26377 :
26378 0 : status = dcerpc_clusapi_GetResourceNetworkName_r_recv(subreq, mem_ctx);
26379 0 : TALLOC_FREE(subreq);
26380 0 : if (tevent_req_nterror(req, status)) {
26381 0 : return;
26382 : }
26383 :
26384 : /* Copy out parameters */
26385 0 : *state->orig.out.lpszName = *state->tmp.out.lpszName;
26386 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
26387 :
26388 : /* Copy result */
26389 0 : state->orig.out.result = state->tmp.out.result;
26390 :
26391 : /* Reset temporary structure */
26392 0 : NDR_ZERO_STRUCT(state->tmp);
26393 :
26394 0 : tevent_req_done(req);
26395 : }
26396 :
26397 0 : NTSTATUS dcerpc_clusapi_GetResourceNetworkName_recv(struct tevent_req *req,
26398 : TALLOC_CTX *mem_ctx,
26399 : WERROR *result)
26400 : {
26401 0 : struct dcerpc_clusapi_GetResourceNetworkName_state *state = tevent_req_data(
26402 : req, struct dcerpc_clusapi_GetResourceNetworkName_state);
26403 : NTSTATUS status;
26404 :
26405 0 : if (tevent_req_is_nterror(req, &status)) {
26406 0 : tevent_req_received(req);
26407 0 : return status;
26408 : }
26409 :
26410 : /* Steal possible out parameters to the callers context */
26411 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26412 :
26413 : /* Return result */
26414 0 : *result = state->orig.out.result;
26415 :
26416 0 : tevent_req_received(req);
26417 0 : return NT_STATUS_OK;
26418 : }
26419 :
26420 0 : NTSTATUS dcerpc_clusapi_GetResourceNetworkName(struct dcerpc_binding_handle *h,
26421 : TALLOC_CTX *mem_ctx,
26422 : struct policy_handle _hResource /* [in] */,
26423 : const char **_lpszName /* [out] [charset(UTF16),ref] */,
26424 : WERROR *_rpc_status /* [out] [ref] */,
26425 : WERROR *result)
26426 : {
26427 : struct clusapi_GetResourceNetworkName r;
26428 : NTSTATUS status;
26429 :
26430 : /* In parameters */
26431 0 : r.in.hResource = _hResource;
26432 :
26433 : /* Out parameters */
26434 0 : r.out.lpszName = _lpszName;
26435 0 : r.out.rpc_status = _rpc_status;
26436 :
26437 : /* Result */
26438 0 : NDR_ZERO_STRUCT(r.out.result);
26439 :
26440 0 : status = dcerpc_clusapi_GetResourceNetworkName_r(h, mem_ctx, &r);
26441 0 : if (!NT_STATUS_IS_OK(status)) {
26442 0 : return status;
26443 : }
26444 :
26445 : /* Return variables */
26446 0 : *_lpszName = *r.out.lpszName;
26447 0 : *_rpc_status = *r.out.rpc_status;
26448 :
26449 : /* Return result */
26450 0 : *result = r.out.result;
26451 :
26452 0 : return NT_STATUS_OK;
26453 : }
26454 :
26455 : struct dcerpc_clusapi_ExecuteBatch_r_state {
26456 : TALLOC_CTX *out_mem_ctx;
26457 : };
26458 :
26459 : static void dcerpc_clusapi_ExecuteBatch_r_done(struct tevent_req *subreq);
26460 :
26461 0 : struct tevent_req *dcerpc_clusapi_ExecuteBatch_r_send(TALLOC_CTX *mem_ctx,
26462 : struct tevent_context *ev,
26463 : struct dcerpc_binding_handle *h,
26464 : struct clusapi_ExecuteBatch *r)
26465 : {
26466 : struct tevent_req *req;
26467 : struct dcerpc_clusapi_ExecuteBatch_r_state *state;
26468 : struct tevent_req *subreq;
26469 :
26470 0 : req = tevent_req_create(mem_ctx, &state,
26471 : struct dcerpc_clusapi_ExecuteBatch_r_state);
26472 0 : if (req == NULL) {
26473 0 : return NULL;
26474 : }
26475 :
26476 0 : state->out_mem_ctx = talloc_new(state);
26477 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26478 0 : return tevent_req_post(req, ev);
26479 : }
26480 :
26481 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
26482 : NULL, &ndr_table_clusapi,
26483 0 : NDR_CLUSAPI_EXECUTEBATCH, state->out_mem_ctx, r);
26484 0 : if (tevent_req_nomem(subreq, req)) {
26485 0 : return tevent_req_post(req, ev);
26486 : }
26487 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteBatch_r_done, req);
26488 :
26489 0 : return req;
26490 : }
26491 :
26492 0 : static void dcerpc_clusapi_ExecuteBatch_r_done(struct tevent_req *subreq)
26493 : {
26494 0 : struct tevent_req *req =
26495 0 : tevent_req_callback_data(subreq,
26496 : struct tevent_req);
26497 : NTSTATUS status;
26498 :
26499 0 : status = dcerpc_binding_handle_call_recv(subreq);
26500 0 : TALLOC_FREE(subreq);
26501 0 : if (tevent_req_nterror(req, status)) {
26502 0 : return;
26503 : }
26504 :
26505 0 : tevent_req_done(req);
26506 : }
26507 :
26508 0 : NTSTATUS dcerpc_clusapi_ExecuteBatch_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
26509 : {
26510 0 : struct dcerpc_clusapi_ExecuteBatch_r_state *state =
26511 0 : tevent_req_data(req,
26512 : struct dcerpc_clusapi_ExecuteBatch_r_state);
26513 : NTSTATUS status;
26514 :
26515 0 : if (tevent_req_is_nterror(req, &status)) {
26516 0 : tevent_req_received(req);
26517 0 : return status;
26518 : }
26519 :
26520 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26521 :
26522 0 : tevent_req_received(req);
26523 0 : return NT_STATUS_OK;
26524 : }
26525 :
26526 0 : NTSTATUS dcerpc_clusapi_ExecuteBatch_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ExecuteBatch *r)
26527 : {
26528 : NTSTATUS status;
26529 :
26530 0 : status = dcerpc_binding_handle_call(h,
26531 : NULL, &ndr_table_clusapi,
26532 : NDR_CLUSAPI_EXECUTEBATCH, mem_ctx, r);
26533 :
26534 0 : return status;
26535 : }
26536 :
26537 : struct dcerpc_clusapi_ExecuteBatch_state {
26538 : struct clusapi_ExecuteBatch orig;
26539 : struct clusapi_ExecuteBatch tmp;
26540 : TALLOC_CTX *out_mem_ctx;
26541 : };
26542 :
26543 : static void dcerpc_clusapi_ExecuteBatch_done(struct tevent_req *subreq);
26544 :
26545 0 : struct tevent_req *dcerpc_clusapi_ExecuteBatch_send(TALLOC_CTX *mem_ctx,
26546 : struct tevent_context *ev,
26547 : struct dcerpc_binding_handle *h,
26548 : struct policy_handle _hKey /* [in] */,
26549 : uint32_t _cbData /* [in] */,
26550 : uint8_t *_lpData /* [in] [ref,size_is(cbData)] */,
26551 : int32_t *_pdwFailedCommand /* [out] [ref] */,
26552 : WERROR *_rpc_status /* [out] [ref] */)
26553 : {
26554 : struct tevent_req *req;
26555 : struct dcerpc_clusapi_ExecuteBatch_state *state;
26556 : struct tevent_req *subreq;
26557 :
26558 0 : req = tevent_req_create(mem_ctx, &state,
26559 : struct dcerpc_clusapi_ExecuteBatch_state);
26560 0 : if (req == NULL) {
26561 0 : return NULL;
26562 : }
26563 0 : state->out_mem_ctx = NULL;
26564 :
26565 : /* In parameters */
26566 0 : state->orig.in.hKey = _hKey;
26567 0 : state->orig.in.cbData = _cbData;
26568 0 : state->orig.in.lpData = _lpData;
26569 :
26570 : /* Out parameters */
26571 0 : state->orig.out.pdwFailedCommand = _pdwFailedCommand;
26572 0 : state->orig.out.rpc_status = _rpc_status;
26573 :
26574 : /* Result */
26575 0 : NDR_ZERO_STRUCT(state->orig.out.result);
26576 :
26577 0 : state->out_mem_ctx = talloc_named_const(state, 0,
26578 : "dcerpc_clusapi_ExecuteBatch_out_memory");
26579 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26580 0 : return tevent_req_post(req, ev);
26581 : }
26582 :
26583 : /* make a temporary copy, that we pass to the dispatch function */
26584 0 : state->tmp = state->orig;
26585 :
26586 0 : subreq = dcerpc_clusapi_ExecuteBatch_r_send(state, ev, h, &state->tmp);
26587 0 : if (tevent_req_nomem(subreq, req)) {
26588 0 : return tevent_req_post(req, ev);
26589 : }
26590 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteBatch_done, req);
26591 0 : return req;
26592 : }
26593 :
26594 0 : static void dcerpc_clusapi_ExecuteBatch_done(struct tevent_req *subreq)
26595 : {
26596 0 : struct tevent_req *req = tevent_req_callback_data(
26597 : subreq, struct tevent_req);
26598 0 : struct dcerpc_clusapi_ExecuteBatch_state *state = tevent_req_data(
26599 : req, struct dcerpc_clusapi_ExecuteBatch_state);
26600 : NTSTATUS status;
26601 : TALLOC_CTX *mem_ctx;
26602 :
26603 0 : if (state->out_mem_ctx) {
26604 0 : mem_ctx = state->out_mem_ctx;
26605 : } else {
26606 0 : mem_ctx = state;
26607 : }
26608 :
26609 0 : status = dcerpc_clusapi_ExecuteBatch_r_recv(subreq, mem_ctx);
26610 0 : TALLOC_FREE(subreq);
26611 0 : if (tevent_req_nterror(req, status)) {
26612 0 : return;
26613 : }
26614 :
26615 : /* Copy out parameters */
26616 0 : *state->orig.out.pdwFailedCommand = *state->tmp.out.pdwFailedCommand;
26617 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
26618 :
26619 : /* Copy result */
26620 0 : state->orig.out.result = state->tmp.out.result;
26621 :
26622 : /* Reset temporary structure */
26623 0 : NDR_ZERO_STRUCT(state->tmp);
26624 :
26625 0 : tevent_req_done(req);
26626 : }
26627 :
26628 0 : NTSTATUS dcerpc_clusapi_ExecuteBatch_recv(struct tevent_req *req,
26629 : TALLOC_CTX *mem_ctx,
26630 : WERROR *result)
26631 : {
26632 0 : struct dcerpc_clusapi_ExecuteBatch_state *state = tevent_req_data(
26633 : req, struct dcerpc_clusapi_ExecuteBatch_state);
26634 : NTSTATUS status;
26635 :
26636 0 : if (tevent_req_is_nterror(req, &status)) {
26637 0 : tevent_req_received(req);
26638 0 : return status;
26639 : }
26640 :
26641 : /* Steal possible out parameters to the callers context */
26642 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26643 :
26644 : /* Return result */
26645 0 : *result = state->orig.out.result;
26646 :
26647 0 : tevent_req_received(req);
26648 0 : return NT_STATUS_OK;
26649 : }
26650 :
26651 0 : NTSTATUS dcerpc_clusapi_ExecuteBatch(struct dcerpc_binding_handle *h,
26652 : TALLOC_CTX *mem_ctx,
26653 : struct policy_handle _hKey /* [in] */,
26654 : uint32_t _cbData /* [in] */,
26655 : uint8_t *_lpData /* [in] [ref,size_is(cbData)] */,
26656 : int32_t *_pdwFailedCommand /* [out] [ref] */,
26657 : WERROR *_rpc_status /* [out] [ref] */,
26658 : WERROR *result)
26659 : {
26660 : struct clusapi_ExecuteBatch r;
26661 : NTSTATUS status;
26662 :
26663 : /* In parameters */
26664 0 : r.in.hKey = _hKey;
26665 0 : r.in.cbData = _cbData;
26666 0 : r.in.lpData = _lpData;
26667 :
26668 : /* Out parameters */
26669 0 : r.out.pdwFailedCommand = _pdwFailedCommand;
26670 0 : r.out.rpc_status = _rpc_status;
26671 :
26672 : /* Result */
26673 0 : NDR_ZERO_STRUCT(r.out.result);
26674 :
26675 0 : status = dcerpc_clusapi_ExecuteBatch_r(h, mem_ctx, &r);
26676 0 : if (!NT_STATUS_IS_OK(status)) {
26677 0 : return status;
26678 : }
26679 :
26680 : /* Return variables */
26681 0 : *_pdwFailedCommand = *r.out.pdwFailedCommand;
26682 0 : *_rpc_status = *r.out.rpc_status;
26683 :
26684 : /* Return result */
26685 0 : *result = r.out.result;
26686 :
26687 0 : return NT_STATUS_OK;
26688 : }
26689 :
26690 : struct dcerpc_clusapi_CreateBatchPort_r_state {
26691 : TALLOC_CTX *out_mem_ctx;
26692 : };
26693 :
26694 : static void dcerpc_clusapi_CreateBatchPort_r_done(struct tevent_req *subreq);
26695 :
26696 0 : struct tevent_req *dcerpc_clusapi_CreateBatchPort_r_send(TALLOC_CTX *mem_ctx,
26697 : struct tevent_context *ev,
26698 : struct dcerpc_binding_handle *h,
26699 : struct clusapi_CreateBatchPort *r)
26700 : {
26701 : struct tevent_req *req;
26702 : struct dcerpc_clusapi_CreateBatchPort_r_state *state;
26703 : struct tevent_req *subreq;
26704 :
26705 0 : req = tevent_req_create(mem_ctx, &state,
26706 : struct dcerpc_clusapi_CreateBatchPort_r_state);
26707 0 : if (req == NULL) {
26708 0 : return NULL;
26709 : }
26710 :
26711 0 : state->out_mem_ctx = talloc_new(state);
26712 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26713 0 : return tevent_req_post(req, ev);
26714 : }
26715 :
26716 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
26717 : NULL, &ndr_table_clusapi,
26718 0 : NDR_CLUSAPI_CREATEBATCHPORT, state->out_mem_ctx, r);
26719 0 : if (tevent_req_nomem(subreq, req)) {
26720 0 : return tevent_req_post(req, ev);
26721 : }
26722 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateBatchPort_r_done, req);
26723 :
26724 0 : return req;
26725 : }
26726 :
26727 0 : static void dcerpc_clusapi_CreateBatchPort_r_done(struct tevent_req *subreq)
26728 : {
26729 0 : struct tevent_req *req =
26730 0 : tevent_req_callback_data(subreq,
26731 : struct tevent_req);
26732 : NTSTATUS status;
26733 :
26734 0 : status = dcerpc_binding_handle_call_recv(subreq);
26735 0 : TALLOC_FREE(subreq);
26736 0 : if (tevent_req_nterror(req, status)) {
26737 0 : return;
26738 : }
26739 :
26740 0 : tevent_req_done(req);
26741 : }
26742 :
26743 0 : NTSTATUS dcerpc_clusapi_CreateBatchPort_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
26744 : {
26745 0 : struct dcerpc_clusapi_CreateBatchPort_r_state *state =
26746 0 : tevent_req_data(req,
26747 : struct dcerpc_clusapi_CreateBatchPort_r_state);
26748 : NTSTATUS status;
26749 :
26750 0 : if (tevent_req_is_nterror(req, &status)) {
26751 0 : tevent_req_received(req);
26752 0 : return status;
26753 : }
26754 :
26755 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26756 :
26757 0 : tevent_req_received(req);
26758 0 : return NT_STATUS_OK;
26759 : }
26760 :
26761 0 : NTSTATUS dcerpc_clusapi_CreateBatchPort_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateBatchPort *r)
26762 : {
26763 : NTSTATUS status;
26764 :
26765 0 : status = dcerpc_binding_handle_call(h,
26766 : NULL, &ndr_table_clusapi,
26767 : NDR_CLUSAPI_CREATEBATCHPORT, mem_ctx, r);
26768 :
26769 0 : return status;
26770 : }
26771 :
26772 : struct dcerpc_clusapi_CreateBatchPort_state {
26773 : struct clusapi_CreateBatchPort orig;
26774 : struct clusapi_CreateBatchPort tmp;
26775 : TALLOC_CTX *out_mem_ctx;
26776 : };
26777 :
26778 : static void dcerpc_clusapi_CreateBatchPort_done(struct tevent_req *subreq);
26779 :
26780 0 : struct tevent_req *dcerpc_clusapi_CreateBatchPort_send(TALLOC_CTX *mem_ctx,
26781 : struct tevent_context *ev,
26782 : struct dcerpc_binding_handle *h,
26783 : struct policy_handle _hKey /* [in] */,
26784 : struct policy_handle *_phBatchPort /* [out] [ref] */,
26785 : WERROR *_rpc_status /* [out] [ref] */)
26786 : {
26787 : struct tevent_req *req;
26788 : struct dcerpc_clusapi_CreateBatchPort_state *state;
26789 : struct tevent_req *subreq;
26790 :
26791 0 : req = tevent_req_create(mem_ctx, &state,
26792 : struct dcerpc_clusapi_CreateBatchPort_state);
26793 0 : if (req == NULL) {
26794 0 : return NULL;
26795 : }
26796 0 : state->out_mem_ctx = NULL;
26797 :
26798 : /* In parameters */
26799 0 : state->orig.in.hKey = _hKey;
26800 :
26801 : /* Out parameters */
26802 0 : state->orig.out.phBatchPort = _phBatchPort;
26803 0 : state->orig.out.rpc_status = _rpc_status;
26804 :
26805 : /* Result */
26806 0 : NDR_ZERO_STRUCT(state->orig.out.result);
26807 :
26808 0 : state->out_mem_ctx = talloc_named_const(state, 0,
26809 : "dcerpc_clusapi_CreateBatchPort_out_memory");
26810 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26811 0 : return tevent_req_post(req, ev);
26812 : }
26813 :
26814 : /* make a temporary copy, that we pass to the dispatch function */
26815 0 : state->tmp = state->orig;
26816 :
26817 0 : subreq = dcerpc_clusapi_CreateBatchPort_r_send(state, ev, h, &state->tmp);
26818 0 : if (tevent_req_nomem(subreq, req)) {
26819 0 : return tevent_req_post(req, ev);
26820 : }
26821 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateBatchPort_done, req);
26822 0 : return req;
26823 : }
26824 :
26825 0 : static void dcerpc_clusapi_CreateBatchPort_done(struct tevent_req *subreq)
26826 : {
26827 0 : struct tevent_req *req = tevent_req_callback_data(
26828 : subreq, struct tevent_req);
26829 0 : struct dcerpc_clusapi_CreateBatchPort_state *state = tevent_req_data(
26830 : req, struct dcerpc_clusapi_CreateBatchPort_state);
26831 : NTSTATUS status;
26832 : TALLOC_CTX *mem_ctx;
26833 :
26834 0 : if (state->out_mem_ctx) {
26835 0 : mem_ctx = state->out_mem_ctx;
26836 : } else {
26837 0 : mem_ctx = state;
26838 : }
26839 :
26840 0 : status = dcerpc_clusapi_CreateBatchPort_r_recv(subreq, mem_ctx);
26841 0 : TALLOC_FREE(subreq);
26842 0 : if (tevent_req_nterror(req, status)) {
26843 0 : return;
26844 : }
26845 :
26846 : /* Copy out parameters */
26847 0 : *state->orig.out.phBatchPort = *state->tmp.out.phBatchPort;
26848 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
26849 :
26850 : /* Copy result */
26851 0 : state->orig.out.result = state->tmp.out.result;
26852 :
26853 : /* Reset temporary structure */
26854 0 : NDR_ZERO_STRUCT(state->tmp);
26855 :
26856 0 : tevent_req_done(req);
26857 : }
26858 :
26859 0 : NTSTATUS dcerpc_clusapi_CreateBatchPort_recv(struct tevent_req *req,
26860 : TALLOC_CTX *mem_ctx,
26861 : WERROR *result)
26862 : {
26863 0 : struct dcerpc_clusapi_CreateBatchPort_state *state = tevent_req_data(
26864 : req, struct dcerpc_clusapi_CreateBatchPort_state);
26865 : NTSTATUS status;
26866 :
26867 0 : if (tevent_req_is_nterror(req, &status)) {
26868 0 : tevent_req_received(req);
26869 0 : return status;
26870 : }
26871 :
26872 : /* Steal possible out parameters to the callers context */
26873 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26874 :
26875 : /* Return result */
26876 0 : *result = state->orig.out.result;
26877 :
26878 0 : tevent_req_received(req);
26879 0 : return NT_STATUS_OK;
26880 : }
26881 :
26882 0 : NTSTATUS dcerpc_clusapi_CreateBatchPort(struct dcerpc_binding_handle *h,
26883 : TALLOC_CTX *mem_ctx,
26884 : struct policy_handle _hKey /* [in] */,
26885 : struct policy_handle *_phBatchPort /* [out] [ref] */,
26886 : WERROR *_rpc_status /* [out] [ref] */,
26887 : WERROR *result)
26888 : {
26889 : struct clusapi_CreateBatchPort r;
26890 : NTSTATUS status;
26891 :
26892 : /* In parameters */
26893 0 : r.in.hKey = _hKey;
26894 :
26895 : /* Out parameters */
26896 0 : r.out.phBatchPort = _phBatchPort;
26897 0 : r.out.rpc_status = _rpc_status;
26898 :
26899 : /* Result */
26900 0 : NDR_ZERO_STRUCT(r.out.result);
26901 :
26902 0 : status = dcerpc_clusapi_CreateBatchPort_r(h, mem_ctx, &r);
26903 0 : if (!NT_STATUS_IS_OK(status)) {
26904 0 : return status;
26905 : }
26906 :
26907 : /* Return variables */
26908 0 : *_phBatchPort = *r.out.phBatchPort;
26909 0 : *_rpc_status = *r.out.rpc_status;
26910 :
26911 : /* Return result */
26912 0 : *result = r.out.result;
26913 :
26914 0 : return NT_STATUS_OK;
26915 : }
26916 :
26917 : struct dcerpc_clusapi_GetBatchNotification_r_state {
26918 : TALLOC_CTX *out_mem_ctx;
26919 : };
26920 :
26921 : static void dcerpc_clusapi_GetBatchNotification_r_done(struct tevent_req *subreq);
26922 :
26923 0 : struct tevent_req *dcerpc_clusapi_GetBatchNotification_r_send(TALLOC_CTX *mem_ctx,
26924 : struct tevent_context *ev,
26925 : struct dcerpc_binding_handle *h,
26926 : struct clusapi_GetBatchNotification *r)
26927 : {
26928 : struct tevent_req *req;
26929 : struct dcerpc_clusapi_GetBatchNotification_r_state *state;
26930 : struct tevent_req *subreq;
26931 :
26932 0 : req = tevent_req_create(mem_ctx, &state,
26933 : struct dcerpc_clusapi_GetBatchNotification_r_state);
26934 0 : if (req == NULL) {
26935 0 : return NULL;
26936 : }
26937 :
26938 0 : state->out_mem_ctx = talloc_new(state);
26939 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
26940 0 : return tevent_req_post(req, ev);
26941 : }
26942 :
26943 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
26944 : NULL, &ndr_table_clusapi,
26945 0 : NDR_CLUSAPI_GETBATCHNOTIFICATION, state->out_mem_ctx, r);
26946 0 : if (tevent_req_nomem(subreq, req)) {
26947 0 : return tevent_req_post(req, ev);
26948 : }
26949 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetBatchNotification_r_done, req);
26950 :
26951 0 : return req;
26952 : }
26953 :
26954 0 : static void dcerpc_clusapi_GetBatchNotification_r_done(struct tevent_req *subreq)
26955 : {
26956 0 : struct tevent_req *req =
26957 0 : tevent_req_callback_data(subreq,
26958 : struct tevent_req);
26959 : NTSTATUS status;
26960 :
26961 0 : status = dcerpc_binding_handle_call_recv(subreq);
26962 0 : TALLOC_FREE(subreq);
26963 0 : if (tevent_req_nterror(req, status)) {
26964 0 : return;
26965 : }
26966 :
26967 0 : tevent_req_done(req);
26968 : }
26969 :
26970 0 : NTSTATUS dcerpc_clusapi_GetBatchNotification_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
26971 : {
26972 0 : struct dcerpc_clusapi_GetBatchNotification_r_state *state =
26973 0 : tevent_req_data(req,
26974 : struct dcerpc_clusapi_GetBatchNotification_r_state);
26975 : NTSTATUS status;
26976 :
26977 0 : if (tevent_req_is_nterror(req, &status)) {
26978 0 : tevent_req_received(req);
26979 0 : return status;
26980 : }
26981 :
26982 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
26983 :
26984 0 : tevent_req_received(req);
26985 0 : return NT_STATUS_OK;
26986 : }
26987 :
26988 0 : NTSTATUS dcerpc_clusapi_GetBatchNotification_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetBatchNotification *r)
26989 : {
26990 : NTSTATUS status;
26991 :
26992 0 : status = dcerpc_binding_handle_call(h,
26993 : NULL, &ndr_table_clusapi,
26994 : NDR_CLUSAPI_GETBATCHNOTIFICATION, mem_ctx, r);
26995 :
26996 0 : return status;
26997 : }
26998 :
26999 : struct dcerpc_clusapi_GetBatchNotification_state {
27000 : struct clusapi_GetBatchNotification orig;
27001 : struct clusapi_GetBatchNotification tmp;
27002 : TALLOC_CTX *out_mem_ctx;
27003 : };
27004 :
27005 : static void dcerpc_clusapi_GetBatchNotification_done(struct tevent_req *subreq);
27006 :
27007 0 : struct tevent_req *dcerpc_clusapi_GetBatchNotification_send(TALLOC_CTX *mem_ctx,
27008 : struct tevent_context *ev,
27009 : struct dcerpc_binding_handle *h,
27010 : struct policy_handle _hBatchNotify /* [in] */,
27011 : uint32_t *_cbData /* [out] [ref] */,
27012 : uint8_t **_lpData /* [out] [ref,size_is(,*cbData)] */)
27013 : {
27014 : struct tevent_req *req;
27015 : struct dcerpc_clusapi_GetBatchNotification_state *state;
27016 : struct tevent_req *subreq;
27017 :
27018 0 : req = tevent_req_create(mem_ctx, &state,
27019 : struct dcerpc_clusapi_GetBatchNotification_state);
27020 0 : if (req == NULL) {
27021 0 : return NULL;
27022 : }
27023 0 : state->out_mem_ctx = NULL;
27024 :
27025 : /* In parameters */
27026 0 : state->orig.in.hBatchNotify = _hBatchNotify;
27027 :
27028 : /* Out parameters */
27029 0 : state->orig.out.cbData = _cbData;
27030 0 : state->orig.out.lpData = _lpData;
27031 :
27032 : /* Result */
27033 0 : NDR_ZERO_STRUCT(state->orig.out.result);
27034 :
27035 0 : state->out_mem_ctx = talloc_named_const(state, 0,
27036 : "dcerpc_clusapi_GetBatchNotification_out_memory");
27037 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27038 0 : return tevent_req_post(req, ev);
27039 : }
27040 :
27041 : /* make a temporary copy, that we pass to the dispatch function */
27042 0 : state->tmp = state->orig;
27043 :
27044 0 : subreq = dcerpc_clusapi_GetBatchNotification_r_send(state, ev, h, &state->tmp);
27045 0 : if (tevent_req_nomem(subreq, req)) {
27046 0 : return tevent_req_post(req, ev);
27047 : }
27048 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetBatchNotification_done, req);
27049 0 : return req;
27050 : }
27051 :
27052 0 : static void dcerpc_clusapi_GetBatchNotification_done(struct tevent_req *subreq)
27053 : {
27054 0 : struct tevent_req *req = tevent_req_callback_data(
27055 : subreq, struct tevent_req);
27056 0 : struct dcerpc_clusapi_GetBatchNotification_state *state = tevent_req_data(
27057 : req, struct dcerpc_clusapi_GetBatchNotification_state);
27058 : NTSTATUS status;
27059 : TALLOC_CTX *mem_ctx;
27060 :
27061 0 : if (state->out_mem_ctx) {
27062 0 : mem_ctx = state->out_mem_ctx;
27063 : } else {
27064 0 : mem_ctx = state;
27065 : }
27066 :
27067 0 : status = dcerpc_clusapi_GetBatchNotification_r_recv(subreq, mem_ctx);
27068 0 : TALLOC_FREE(subreq);
27069 0 : if (tevent_req_nterror(req, status)) {
27070 0 : return;
27071 : }
27072 :
27073 : /* Copy out parameters */
27074 0 : *state->orig.out.cbData = *state->tmp.out.cbData;
27075 0 : *state->orig.out.lpData = *state->tmp.out.lpData;
27076 :
27077 : /* Copy result */
27078 0 : state->orig.out.result = state->tmp.out.result;
27079 :
27080 : /* Reset temporary structure */
27081 0 : NDR_ZERO_STRUCT(state->tmp);
27082 :
27083 0 : tevent_req_done(req);
27084 : }
27085 :
27086 0 : NTSTATUS dcerpc_clusapi_GetBatchNotification_recv(struct tevent_req *req,
27087 : TALLOC_CTX *mem_ctx,
27088 : WERROR *result)
27089 : {
27090 0 : struct dcerpc_clusapi_GetBatchNotification_state *state = tevent_req_data(
27091 : req, struct dcerpc_clusapi_GetBatchNotification_state);
27092 : NTSTATUS status;
27093 :
27094 0 : if (tevent_req_is_nterror(req, &status)) {
27095 0 : tevent_req_received(req);
27096 0 : return status;
27097 : }
27098 :
27099 : /* Steal possible out parameters to the callers context */
27100 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27101 :
27102 : /* Return result */
27103 0 : *result = state->orig.out.result;
27104 :
27105 0 : tevent_req_received(req);
27106 0 : return NT_STATUS_OK;
27107 : }
27108 :
27109 0 : NTSTATUS dcerpc_clusapi_GetBatchNotification(struct dcerpc_binding_handle *h,
27110 : TALLOC_CTX *mem_ctx,
27111 : struct policy_handle _hBatchNotify /* [in] */,
27112 : uint32_t *_cbData /* [out] [ref] */,
27113 : uint8_t **_lpData /* [out] [ref,size_is(,*cbData)] */,
27114 : WERROR *result)
27115 : {
27116 : struct clusapi_GetBatchNotification r;
27117 : NTSTATUS status;
27118 :
27119 : /* In parameters */
27120 0 : r.in.hBatchNotify = _hBatchNotify;
27121 :
27122 : /* Out parameters */
27123 0 : r.out.cbData = _cbData;
27124 0 : r.out.lpData = _lpData;
27125 :
27126 : /* Result */
27127 0 : NDR_ZERO_STRUCT(r.out.result);
27128 :
27129 0 : status = dcerpc_clusapi_GetBatchNotification_r(h, mem_ctx, &r);
27130 0 : if (!NT_STATUS_IS_OK(status)) {
27131 0 : return status;
27132 : }
27133 :
27134 : /* Return variables */
27135 0 : *_cbData = *r.out.cbData;
27136 0 : *_lpData = *r.out.lpData;
27137 :
27138 : /* Return result */
27139 0 : *result = r.out.result;
27140 :
27141 0 : return NT_STATUS_OK;
27142 : }
27143 :
27144 : struct dcerpc_clusapi_CloseBatchPort_r_state {
27145 : TALLOC_CTX *out_mem_ctx;
27146 : };
27147 :
27148 : static void dcerpc_clusapi_CloseBatchPort_r_done(struct tevent_req *subreq);
27149 :
27150 0 : struct tevent_req *dcerpc_clusapi_CloseBatchPort_r_send(TALLOC_CTX *mem_ctx,
27151 : struct tevent_context *ev,
27152 : struct dcerpc_binding_handle *h,
27153 : struct clusapi_CloseBatchPort *r)
27154 : {
27155 : struct tevent_req *req;
27156 : struct dcerpc_clusapi_CloseBatchPort_r_state *state;
27157 : struct tevent_req *subreq;
27158 :
27159 0 : req = tevent_req_create(mem_ctx, &state,
27160 : struct dcerpc_clusapi_CloseBatchPort_r_state);
27161 0 : if (req == NULL) {
27162 0 : return NULL;
27163 : }
27164 :
27165 0 : state->out_mem_ctx = talloc_new(state);
27166 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27167 0 : return tevent_req_post(req, ev);
27168 : }
27169 :
27170 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
27171 : NULL, &ndr_table_clusapi,
27172 0 : NDR_CLUSAPI_CLOSEBATCHPORT, state->out_mem_ctx, r);
27173 0 : if (tevent_req_nomem(subreq, req)) {
27174 0 : return tevent_req_post(req, ev);
27175 : }
27176 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseBatchPort_r_done, req);
27177 :
27178 0 : return req;
27179 : }
27180 :
27181 0 : static void dcerpc_clusapi_CloseBatchPort_r_done(struct tevent_req *subreq)
27182 : {
27183 0 : struct tevent_req *req =
27184 0 : tevent_req_callback_data(subreq,
27185 : struct tevent_req);
27186 : NTSTATUS status;
27187 :
27188 0 : status = dcerpc_binding_handle_call_recv(subreq);
27189 0 : TALLOC_FREE(subreq);
27190 0 : if (tevent_req_nterror(req, status)) {
27191 0 : return;
27192 : }
27193 :
27194 0 : tevent_req_done(req);
27195 : }
27196 :
27197 0 : NTSTATUS dcerpc_clusapi_CloseBatchPort_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
27198 : {
27199 0 : struct dcerpc_clusapi_CloseBatchPort_r_state *state =
27200 0 : tevent_req_data(req,
27201 : struct dcerpc_clusapi_CloseBatchPort_r_state);
27202 : NTSTATUS status;
27203 :
27204 0 : if (tevent_req_is_nterror(req, &status)) {
27205 0 : tevent_req_received(req);
27206 0 : return status;
27207 : }
27208 :
27209 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27210 :
27211 0 : tevent_req_received(req);
27212 0 : return NT_STATUS_OK;
27213 : }
27214 :
27215 0 : NTSTATUS dcerpc_clusapi_CloseBatchPort_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseBatchPort *r)
27216 : {
27217 : NTSTATUS status;
27218 :
27219 0 : status = dcerpc_binding_handle_call(h,
27220 : NULL, &ndr_table_clusapi,
27221 : NDR_CLUSAPI_CLOSEBATCHPORT, mem_ctx, r);
27222 :
27223 0 : return status;
27224 : }
27225 :
27226 : struct dcerpc_clusapi_CloseBatchPort_state {
27227 : struct clusapi_CloseBatchPort orig;
27228 : struct clusapi_CloseBatchPort tmp;
27229 : TALLOC_CTX *out_mem_ctx;
27230 : };
27231 :
27232 : static void dcerpc_clusapi_CloseBatchPort_done(struct tevent_req *subreq);
27233 :
27234 0 : struct tevent_req *dcerpc_clusapi_CloseBatchPort_send(TALLOC_CTX *mem_ctx,
27235 : struct tevent_context *ev,
27236 : struct dcerpc_binding_handle *h,
27237 : struct policy_handle *_phBatchPort /* [in,out] [ref] */)
27238 : {
27239 : struct tevent_req *req;
27240 : struct dcerpc_clusapi_CloseBatchPort_state *state;
27241 : struct tevent_req *subreq;
27242 :
27243 0 : req = tevent_req_create(mem_ctx, &state,
27244 : struct dcerpc_clusapi_CloseBatchPort_state);
27245 0 : if (req == NULL) {
27246 0 : return NULL;
27247 : }
27248 0 : state->out_mem_ctx = NULL;
27249 :
27250 : /* In parameters */
27251 0 : state->orig.in.phBatchPort = _phBatchPort;
27252 :
27253 : /* Out parameters */
27254 0 : state->orig.out.phBatchPort = _phBatchPort;
27255 :
27256 : /* Result */
27257 0 : NDR_ZERO_STRUCT(state->orig.out.result);
27258 :
27259 0 : state->out_mem_ctx = talloc_named_const(state, 0,
27260 : "dcerpc_clusapi_CloseBatchPort_out_memory");
27261 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27262 0 : return tevent_req_post(req, ev);
27263 : }
27264 :
27265 : /* make a temporary copy, that we pass to the dispatch function */
27266 0 : state->tmp = state->orig;
27267 :
27268 0 : subreq = dcerpc_clusapi_CloseBatchPort_r_send(state, ev, h, &state->tmp);
27269 0 : if (tevent_req_nomem(subreq, req)) {
27270 0 : return tevent_req_post(req, ev);
27271 : }
27272 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseBatchPort_done, req);
27273 0 : return req;
27274 : }
27275 :
27276 0 : static void dcerpc_clusapi_CloseBatchPort_done(struct tevent_req *subreq)
27277 : {
27278 0 : struct tevent_req *req = tevent_req_callback_data(
27279 : subreq, struct tevent_req);
27280 0 : struct dcerpc_clusapi_CloseBatchPort_state *state = tevent_req_data(
27281 : req, struct dcerpc_clusapi_CloseBatchPort_state);
27282 : NTSTATUS status;
27283 : TALLOC_CTX *mem_ctx;
27284 :
27285 0 : if (state->out_mem_ctx) {
27286 0 : mem_ctx = state->out_mem_ctx;
27287 : } else {
27288 0 : mem_ctx = state;
27289 : }
27290 :
27291 0 : status = dcerpc_clusapi_CloseBatchPort_r_recv(subreq, mem_ctx);
27292 0 : TALLOC_FREE(subreq);
27293 0 : if (tevent_req_nterror(req, status)) {
27294 0 : return;
27295 : }
27296 :
27297 : /* Copy out parameters */
27298 0 : *state->orig.out.phBatchPort = *state->tmp.out.phBatchPort;
27299 :
27300 : /* Copy result */
27301 0 : state->orig.out.result = state->tmp.out.result;
27302 :
27303 : /* Reset temporary structure */
27304 0 : NDR_ZERO_STRUCT(state->tmp);
27305 :
27306 0 : tevent_req_done(req);
27307 : }
27308 :
27309 0 : NTSTATUS dcerpc_clusapi_CloseBatchPort_recv(struct tevent_req *req,
27310 : TALLOC_CTX *mem_ctx,
27311 : WERROR *result)
27312 : {
27313 0 : struct dcerpc_clusapi_CloseBatchPort_state *state = tevent_req_data(
27314 : req, struct dcerpc_clusapi_CloseBatchPort_state);
27315 : NTSTATUS status;
27316 :
27317 0 : if (tevent_req_is_nterror(req, &status)) {
27318 0 : tevent_req_received(req);
27319 0 : return status;
27320 : }
27321 :
27322 : /* Steal possible out parameters to the callers context */
27323 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27324 :
27325 : /* Return result */
27326 0 : *result = state->orig.out.result;
27327 :
27328 0 : tevent_req_received(req);
27329 0 : return NT_STATUS_OK;
27330 : }
27331 :
27332 0 : NTSTATUS dcerpc_clusapi_CloseBatchPort(struct dcerpc_binding_handle *h,
27333 : TALLOC_CTX *mem_ctx,
27334 : struct policy_handle *_phBatchPort /* [in,out] [ref] */,
27335 : WERROR *result)
27336 : {
27337 : struct clusapi_CloseBatchPort r;
27338 : NTSTATUS status;
27339 :
27340 : /* In parameters */
27341 0 : r.in.phBatchPort = _phBatchPort;
27342 :
27343 : /* Out parameters */
27344 0 : r.out.phBatchPort = _phBatchPort;
27345 :
27346 : /* Result */
27347 0 : NDR_ZERO_STRUCT(r.out.result);
27348 :
27349 0 : status = dcerpc_clusapi_CloseBatchPort_r(h, mem_ctx, &r);
27350 0 : if (!NT_STATUS_IS_OK(status)) {
27351 0 : return status;
27352 : }
27353 :
27354 : /* Return variables */
27355 0 : *_phBatchPort = *r.out.phBatchPort;
27356 :
27357 : /* Return result */
27358 0 : *result = r.out.result;
27359 :
27360 0 : return NT_STATUS_OK;
27361 : }
27362 :
27363 : struct dcerpc_clusapi_OpenClusterEx_r_state {
27364 : TALLOC_CTX *out_mem_ctx;
27365 : };
27366 :
27367 : static void dcerpc_clusapi_OpenClusterEx_r_done(struct tevent_req *subreq);
27368 :
27369 0 : struct tevent_req *dcerpc_clusapi_OpenClusterEx_r_send(TALLOC_CTX *mem_ctx,
27370 : struct tevent_context *ev,
27371 : struct dcerpc_binding_handle *h,
27372 : struct clusapi_OpenClusterEx *r)
27373 : {
27374 : struct tevent_req *req;
27375 : struct dcerpc_clusapi_OpenClusterEx_r_state *state;
27376 : struct tevent_req *subreq;
27377 :
27378 0 : req = tevent_req_create(mem_ctx, &state,
27379 : struct dcerpc_clusapi_OpenClusterEx_r_state);
27380 0 : if (req == NULL) {
27381 0 : return NULL;
27382 : }
27383 :
27384 0 : state->out_mem_ctx = talloc_new(state);
27385 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27386 0 : return tevent_req_post(req, ev);
27387 : }
27388 :
27389 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
27390 : NULL, &ndr_table_clusapi,
27391 0 : NDR_CLUSAPI_OPENCLUSTEREX, state->out_mem_ctx, r);
27392 0 : if (tevent_req_nomem(subreq, req)) {
27393 0 : return tevent_req_post(req, ev);
27394 : }
27395 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenClusterEx_r_done, req);
27396 :
27397 0 : return req;
27398 : }
27399 :
27400 0 : static void dcerpc_clusapi_OpenClusterEx_r_done(struct tevent_req *subreq)
27401 : {
27402 0 : struct tevent_req *req =
27403 0 : tevent_req_callback_data(subreq,
27404 : struct tevent_req);
27405 : NTSTATUS status;
27406 :
27407 0 : status = dcerpc_binding_handle_call_recv(subreq);
27408 0 : TALLOC_FREE(subreq);
27409 0 : if (tevent_req_nterror(req, status)) {
27410 0 : return;
27411 : }
27412 :
27413 0 : tevent_req_done(req);
27414 : }
27415 :
27416 0 : NTSTATUS dcerpc_clusapi_OpenClusterEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
27417 : {
27418 0 : struct dcerpc_clusapi_OpenClusterEx_r_state *state =
27419 0 : tevent_req_data(req,
27420 : struct dcerpc_clusapi_OpenClusterEx_r_state);
27421 : NTSTATUS status;
27422 :
27423 0 : if (tevent_req_is_nterror(req, &status)) {
27424 0 : tevent_req_received(req);
27425 0 : return status;
27426 : }
27427 :
27428 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27429 :
27430 0 : tevent_req_received(req);
27431 0 : return NT_STATUS_OK;
27432 : }
27433 :
27434 0 : NTSTATUS dcerpc_clusapi_OpenClusterEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenClusterEx *r)
27435 : {
27436 : NTSTATUS status;
27437 :
27438 0 : status = dcerpc_binding_handle_call(h,
27439 : NULL, &ndr_table_clusapi,
27440 : NDR_CLUSAPI_OPENCLUSTEREX, mem_ctx, r);
27441 :
27442 0 : return status;
27443 : }
27444 :
27445 : struct dcerpc_clusapi_OpenClusterEx_state {
27446 : struct clusapi_OpenClusterEx orig;
27447 : struct clusapi_OpenClusterEx tmp;
27448 : TALLOC_CTX *out_mem_ctx;
27449 : };
27450 :
27451 : static void dcerpc_clusapi_OpenClusterEx_done(struct tevent_req *subreq);
27452 :
27453 0 : struct tevent_req *dcerpc_clusapi_OpenClusterEx_send(TALLOC_CTX *mem_ctx,
27454 : struct tevent_context *ev,
27455 : struct dcerpc_binding_handle *h,
27456 : uint32_t _dwDesiredAccess /* [in] */,
27457 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
27458 : WERROR *_Status /* [out] [ref] */,
27459 : struct policy_handle *_hCluster /* [out] [ref] */)
27460 : {
27461 : struct tevent_req *req;
27462 : struct dcerpc_clusapi_OpenClusterEx_state *state;
27463 : struct tevent_req *subreq;
27464 :
27465 0 : req = tevent_req_create(mem_ctx, &state,
27466 : struct dcerpc_clusapi_OpenClusterEx_state);
27467 0 : if (req == NULL) {
27468 0 : return NULL;
27469 : }
27470 0 : state->out_mem_ctx = NULL;
27471 :
27472 : /* In parameters */
27473 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
27474 :
27475 : /* Out parameters */
27476 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
27477 0 : state->orig.out.Status = _Status;
27478 0 : state->orig.out.hCluster = _hCluster;
27479 :
27480 0 : state->out_mem_ctx = talloc_named_const(state, 0,
27481 : "dcerpc_clusapi_OpenClusterEx_out_memory");
27482 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27483 0 : return tevent_req_post(req, ev);
27484 : }
27485 :
27486 : /* make a temporary copy, that we pass to the dispatch function */
27487 0 : state->tmp = state->orig;
27488 :
27489 0 : subreq = dcerpc_clusapi_OpenClusterEx_r_send(state, ev, h, &state->tmp);
27490 0 : if (tevent_req_nomem(subreq, req)) {
27491 0 : return tevent_req_post(req, ev);
27492 : }
27493 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenClusterEx_done, req);
27494 0 : return req;
27495 : }
27496 :
27497 0 : static void dcerpc_clusapi_OpenClusterEx_done(struct tevent_req *subreq)
27498 : {
27499 0 : struct tevent_req *req = tevent_req_callback_data(
27500 : subreq, struct tevent_req);
27501 0 : struct dcerpc_clusapi_OpenClusterEx_state *state = tevent_req_data(
27502 : req, struct dcerpc_clusapi_OpenClusterEx_state);
27503 : NTSTATUS status;
27504 : TALLOC_CTX *mem_ctx;
27505 :
27506 0 : if (state->out_mem_ctx) {
27507 0 : mem_ctx = state->out_mem_ctx;
27508 : } else {
27509 0 : mem_ctx = state;
27510 : }
27511 :
27512 0 : status = dcerpc_clusapi_OpenClusterEx_r_recv(subreq, mem_ctx);
27513 0 : TALLOC_FREE(subreq);
27514 0 : if (tevent_req_nterror(req, status)) {
27515 0 : return;
27516 : }
27517 :
27518 : /* Copy out parameters */
27519 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
27520 0 : *state->orig.out.Status = *state->tmp.out.Status;
27521 0 : *state->orig.out.hCluster = *state->tmp.out.hCluster;
27522 :
27523 : /* Reset temporary structure */
27524 0 : NDR_ZERO_STRUCT(state->tmp);
27525 :
27526 0 : tevent_req_done(req);
27527 : }
27528 :
27529 0 : NTSTATUS dcerpc_clusapi_OpenClusterEx_recv(struct tevent_req *req,
27530 : TALLOC_CTX *mem_ctx)
27531 : {
27532 0 : struct dcerpc_clusapi_OpenClusterEx_state *state = tevent_req_data(
27533 : req, struct dcerpc_clusapi_OpenClusterEx_state);
27534 : NTSTATUS status;
27535 :
27536 0 : if (tevent_req_is_nterror(req, &status)) {
27537 0 : tevent_req_received(req);
27538 0 : return status;
27539 : }
27540 :
27541 : /* Steal possible out parameters to the callers context */
27542 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27543 :
27544 0 : tevent_req_received(req);
27545 0 : return NT_STATUS_OK;
27546 : }
27547 :
27548 0 : NTSTATUS dcerpc_clusapi_OpenClusterEx(struct dcerpc_binding_handle *h,
27549 : TALLOC_CTX *mem_ctx,
27550 : uint32_t _dwDesiredAccess /* [in] */,
27551 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
27552 : WERROR *_Status /* [out] [ref] */,
27553 : struct policy_handle *_hCluster /* [out] [ref] */)
27554 : {
27555 : struct clusapi_OpenClusterEx r;
27556 : NTSTATUS status;
27557 :
27558 : /* In parameters */
27559 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
27560 :
27561 : /* Out parameters */
27562 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
27563 0 : r.out.Status = _Status;
27564 0 : r.out.hCluster = _hCluster;
27565 :
27566 0 : status = dcerpc_clusapi_OpenClusterEx_r(h, mem_ctx, &r);
27567 0 : if (!NT_STATUS_IS_OK(status)) {
27568 0 : return status;
27569 : }
27570 :
27571 : /* Return variables */
27572 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
27573 0 : *_Status = *r.out.Status;
27574 0 : *_hCluster = *r.out.hCluster;
27575 :
27576 : /* Return result */
27577 :
27578 0 : return NT_STATUS_OK;
27579 : }
27580 :
27581 : struct dcerpc_clusapi_OpenNodeEx_r_state {
27582 : TALLOC_CTX *out_mem_ctx;
27583 : };
27584 :
27585 : static void dcerpc_clusapi_OpenNodeEx_r_done(struct tevent_req *subreq);
27586 :
27587 0 : struct tevent_req *dcerpc_clusapi_OpenNodeEx_r_send(TALLOC_CTX *mem_ctx,
27588 : struct tevent_context *ev,
27589 : struct dcerpc_binding_handle *h,
27590 : struct clusapi_OpenNodeEx *r)
27591 : {
27592 : struct tevent_req *req;
27593 : struct dcerpc_clusapi_OpenNodeEx_r_state *state;
27594 : struct tevent_req *subreq;
27595 :
27596 0 : req = tevent_req_create(mem_ctx, &state,
27597 : struct dcerpc_clusapi_OpenNodeEx_r_state);
27598 0 : if (req == NULL) {
27599 0 : return NULL;
27600 : }
27601 :
27602 0 : state->out_mem_ctx = talloc_new(state);
27603 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27604 0 : return tevent_req_post(req, ev);
27605 : }
27606 :
27607 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
27608 : NULL, &ndr_table_clusapi,
27609 0 : NDR_CLUSAPI_OPENNODEEX, state->out_mem_ctx, r);
27610 0 : if (tevent_req_nomem(subreq, req)) {
27611 0 : return tevent_req_post(req, ev);
27612 : }
27613 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNodeEx_r_done, req);
27614 :
27615 0 : return req;
27616 : }
27617 :
27618 0 : static void dcerpc_clusapi_OpenNodeEx_r_done(struct tevent_req *subreq)
27619 : {
27620 0 : struct tevent_req *req =
27621 0 : tevent_req_callback_data(subreq,
27622 : struct tevent_req);
27623 : NTSTATUS status;
27624 :
27625 0 : status = dcerpc_binding_handle_call_recv(subreq);
27626 0 : TALLOC_FREE(subreq);
27627 0 : if (tevent_req_nterror(req, status)) {
27628 0 : return;
27629 : }
27630 :
27631 0 : tevent_req_done(req);
27632 : }
27633 :
27634 0 : NTSTATUS dcerpc_clusapi_OpenNodeEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
27635 : {
27636 0 : struct dcerpc_clusapi_OpenNodeEx_r_state *state =
27637 0 : tevent_req_data(req,
27638 : struct dcerpc_clusapi_OpenNodeEx_r_state);
27639 : NTSTATUS status;
27640 :
27641 0 : if (tevent_req_is_nterror(req, &status)) {
27642 0 : tevent_req_received(req);
27643 0 : return status;
27644 : }
27645 :
27646 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27647 :
27648 0 : tevent_req_received(req);
27649 0 : return NT_STATUS_OK;
27650 : }
27651 :
27652 0 : NTSTATUS dcerpc_clusapi_OpenNodeEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNodeEx *r)
27653 : {
27654 : NTSTATUS status;
27655 :
27656 0 : status = dcerpc_binding_handle_call(h,
27657 : NULL, &ndr_table_clusapi,
27658 : NDR_CLUSAPI_OPENNODEEX, mem_ctx, r);
27659 :
27660 0 : return status;
27661 : }
27662 :
27663 : struct dcerpc_clusapi_OpenNodeEx_state {
27664 : struct clusapi_OpenNodeEx orig;
27665 : struct clusapi_OpenNodeEx tmp;
27666 : TALLOC_CTX *out_mem_ctx;
27667 : };
27668 :
27669 : static void dcerpc_clusapi_OpenNodeEx_done(struct tevent_req *subreq);
27670 :
27671 0 : struct tevent_req *dcerpc_clusapi_OpenNodeEx_send(TALLOC_CTX *mem_ctx,
27672 : struct tevent_context *ev,
27673 : struct dcerpc_binding_handle *h,
27674 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
27675 : uint32_t _dwDesiredAccess /* [in] */,
27676 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
27677 : WERROR *_Status /* [out] [ref] */,
27678 : WERROR *_rpc_status /* [out] [ref] */,
27679 : struct policy_handle *_hNode /* [out] [ref] */)
27680 : {
27681 : struct tevent_req *req;
27682 : struct dcerpc_clusapi_OpenNodeEx_state *state;
27683 : struct tevent_req *subreq;
27684 :
27685 0 : req = tevent_req_create(mem_ctx, &state,
27686 : struct dcerpc_clusapi_OpenNodeEx_state);
27687 0 : if (req == NULL) {
27688 0 : return NULL;
27689 : }
27690 0 : state->out_mem_ctx = NULL;
27691 :
27692 : /* In parameters */
27693 0 : state->orig.in.lpszNodeName = _lpszNodeName;
27694 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
27695 :
27696 : /* Out parameters */
27697 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
27698 0 : state->orig.out.Status = _Status;
27699 0 : state->orig.out.rpc_status = _rpc_status;
27700 0 : state->orig.out.hNode = _hNode;
27701 :
27702 0 : state->out_mem_ctx = talloc_named_const(state, 0,
27703 : "dcerpc_clusapi_OpenNodeEx_out_memory");
27704 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27705 0 : return tevent_req_post(req, ev);
27706 : }
27707 :
27708 : /* make a temporary copy, that we pass to the dispatch function */
27709 0 : state->tmp = state->orig;
27710 :
27711 0 : subreq = dcerpc_clusapi_OpenNodeEx_r_send(state, ev, h, &state->tmp);
27712 0 : if (tevent_req_nomem(subreq, req)) {
27713 0 : return tevent_req_post(req, ev);
27714 : }
27715 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNodeEx_done, req);
27716 0 : return req;
27717 : }
27718 :
27719 0 : static void dcerpc_clusapi_OpenNodeEx_done(struct tevent_req *subreq)
27720 : {
27721 0 : struct tevent_req *req = tevent_req_callback_data(
27722 : subreq, struct tevent_req);
27723 0 : struct dcerpc_clusapi_OpenNodeEx_state *state = tevent_req_data(
27724 : req, struct dcerpc_clusapi_OpenNodeEx_state);
27725 : NTSTATUS status;
27726 : TALLOC_CTX *mem_ctx;
27727 :
27728 0 : if (state->out_mem_ctx) {
27729 0 : mem_ctx = state->out_mem_ctx;
27730 : } else {
27731 0 : mem_ctx = state;
27732 : }
27733 :
27734 0 : status = dcerpc_clusapi_OpenNodeEx_r_recv(subreq, mem_ctx);
27735 0 : TALLOC_FREE(subreq);
27736 0 : if (tevent_req_nterror(req, status)) {
27737 0 : return;
27738 : }
27739 :
27740 : /* Copy out parameters */
27741 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
27742 0 : *state->orig.out.Status = *state->tmp.out.Status;
27743 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
27744 0 : *state->orig.out.hNode = *state->tmp.out.hNode;
27745 :
27746 : /* Reset temporary structure */
27747 0 : NDR_ZERO_STRUCT(state->tmp);
27748 :
27749 0 : tevent_req_done(req);
27750 : }
27751 :
27752 0 : NTSTATUS dcerpc_clusapi_OpenNodeEx_recv(struct tevent_req *req,
27753 : TALLOC_CTX *mem_ctx)
27754 : {
27755 0 : struct dcerpc_clusapi_OpenNodeEx_state *state = tevent_req_data(
27756 : req, struct dcerpc_clusapi_OpenNodeEx_state);
27757 : NTSTATUS status;
27758 :
27759 0 : if (tevent_req_is_nterror(req, &status)) {
27760 0 : tevent_req_received(req);
27761 0 : return status;
27762 : }
27763 :
27764 : /* Steal possible out parameters to the callers context */
27765 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27766 :
27767 0 : tevent_req_received(req);
27768 0 : return NT_STATUS_OK;
27769 : }
27770 :
27771 0 : NTSTATUS dcerpc_clusapi_OpenNodeEx(struct dcerpc_binding_handle *h,
27772 : TALLOC_CTX *mem_ctx,
27773 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
27774 : uint32_t _dwDesiredAccess /* [in] */,
27775 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
27776 : WERROR *_Status /* [out] [ref] */,
27777 : WERROR *_rpc_status /* [out] [ref] */,
27778 : struct policy_handle *_hNode /* [out] [ref] */)
27779 : {
27780 : struct clusapi_OpenNodeEx r;
27781 : NTSTATUS status;
27782 :
27783 : /* In parameters */
27784 0 : r.in.lpszNodeName = _lpszNodeName;
27785 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
27786 :
27787 : /* Out parameters */
27788 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
27789 0 : r.out.Status = _Status;
27790 0 : r.out.rpc_status = _rpc_status;
27791 0 : r.out.hNode = _hNode;
27792 :
27793 0 : status = dcerpc_clusapi_OpenNodeEx_r(h, mem_ctx, &r);
27794 0 : if (!NT_STATUS_IS_OK(status)) {
27795 0 : return status;
27796 : }
27797 :
27798 : /* Return variables */
27799 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
27800 0 : *_Status = *r.out.Status;
27801 0 : *_rpc_status = *r.out.rpc_status;
27802 0 : *_hNode = *r.out.hNode;
27803 :
27804 : /* Return result */
27805 :
27806 0 : return NT_STATUS_OK;
27807 : }
27808 :
27809 : struct dcerpc_clusapi_OpenGroupEx_r_state {
27810 : TALLOC_CTX *out_mem_ctx;
27811 : };
27812 :
27813 : static void dcerpc_clusapi_OpenGroupEx_r_done(struct tevent_req *subreq);
27814 :
27815 0 : struct tevent_req *dcerpc_clusapi_OpenGroupEx_r_send(TALLOC_CTX *mem_ctx,
27816 : struct tevent_context *ev,
27817 : struct dcerpc_binding_handle *h,
27818 : struct clusapi_OpenGroupEx *r)
27819 : {
27820 : struct tevent_req *req;
27821 : struct dcerpc_clusapi_OpenGroupEx_r_state *state;
27822 : struct tevent_req *subreq;
27823 :
27824 0 : req = tevent_req_create(mem_ctx, &state,
27825 : struct dcerpc_clusapi_OpenGroupEx_r_state);
27826 0 : if (req == NULL) {
27827 0 : return NULL;
27828 : }
27829 :
27830 0 : state->out_mem_ctx = talloc_new(state);
27831 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27832 0 : return tevent_req_post(req, ev);
27833 : }
27834 :
27835 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
27836 : NULL, &ndr_table_clusapi,
27837 0 : NDR_CLUSAPI_OPENGROUPEX, state->out_mem_ctx, r);
27838 0 : if (tevent_req_nomem(subreq, req)) {
27839 0 : return tevent_req_post(req, ev);
27840 : }
27841 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroupEx_r_done, req);
27842 :
27843 0 : return req;
27844 : }
27845 :
27846 0 : static void dcerpc_clusapi_OpenGroupEx_r_done(struct tevent_req *subreq)
27847 : {
27848 0 : struct tevent_req *req =
27849 0 : tevent_req_callback_data(subreq,
27850 : struct tevent_req);
27851 : NTSTATUS status;
27852 :
27853 0 : status = dcerpc_binding_handle_call_recv(subreq);
27854 0 : TALLOC_FREE(subreq);
27855 0 : if (tevent_req_nterror(req, status)) {
27856 0 : return;
27857 : }
27858 :
27859 0 : tevent_req_done(req);
27860 : }
27861 :
27862 0 : NTSTATUS dcerpc_clusapi_OpenGroupEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
27863 : {
27864 0 : struct dcerpc_clusapi_OpenGroupEx_r_state *state =
27865 0 : tevent_req_data(req,
27866 : struct dcerpc_clusapi_OpenGroupEx_r_state);
27867 : NTSTATUS status;
27868 :
27869 0 : if (tevent_req_is_nterror(req, &status)) {
27870 0 : tevent_req_received(req);
27871 0 : return status;
27872 : }
27873 :
27874 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27875 :
27876 0 : tevent_req_received(req);
27877 0 : return NT_STATUS_OK;
27878 : }
27879 :
27880 0 : NTSTATUS dcerpc_clusapi_OpenGroupEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenGroupEx *r)
27881 : {
27882 : NTSTATUS status;
27883 :
27884 0 : status = dcerpc_binding_handle_call(h,
27885 : NULL, &ndr_table_clusapi,
27886 : NDR_CLUSAPI_OPENGROUPEX, mem_ctx, r);
27887 :
27888 0 : return status;
27889 : }
27890 :
27891 : struct dcerpc_clusapi_OpenGroupEx_state {
27892 : struct clusapi_OpenGroupEx orig;
27893 : struct clusapi_OpenGroupEx tmp;
27894 : TALLOC_CTX *out_mem_ctx;
27895 : };
27896 :
27897 : static void dcerpc_clusapi_OpenGroupEx_done(struct tevent_req *subreq);
27898 :
27899 0 : struct tevent_req *dcerpc_clusapi_OpenGroupEx_send(TALLOC_CTX *mem_ctx,
27900 : struct tevent_context *ev,
27901 : struct dcerpc_binding_handle *h,
27902 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
27903 : uint32_t _dwDesiredAccess /* [in] */,
27904 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
27905 : WERROR *_Status /* [out] [ref] */,
27906 : WERROR *_rpc_status /* [out] [ref] */,
27907 : struct policy_handle *_hGroup /* [out] [ref] */)
27908 : {
27909 : struct tevent_req *req;
27910 : struct dcerpc_clusapi_OpenGroupEx_state *state;
27911 : struct tevent_req *subreq;
27912 :
27913 0 : req = tevent_req_create(mem_ctx, &state,
27914 : struct dcerpc_clusapi_OpenGroupEx_state);
27915 0 : if (req == NULL) {
27916 0 : return NULL;
27917 : }
27918 0 : state->out_mem_ctx = NULL;
27919 :
27920 : /* In parameters */
27921 0 : state->orig.in.lpszGroupName = _lpszGroupName;
27922 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
27923 :
27924 : /* Out parameters */
27925 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
27926 0 : state->orig.out.Status = _Status;
27927 0 : state->orig.out.rpc_status = _rpc_status;
27928 0 : state->orig.out.hGroup = _hGroup;
27929 :
27930 0 : state->out_mem_ctx = talloc_named_const(state, 0,
27931 : "dcerpc_clusapi_OpenGroupEx_out_memory");
27932 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
27933 0 : return tevent_req_post(req, ev);
27934 : }
27935 :
27936 : /* make a temporary copy, that we pass to the dispatch function */
27937 0 : state->tmp = state->orig;
27938 :
27939 0 : subreq = dcerpc_clusapi_OpenGroupEx_r_send(state, ev, h, &state->tmp);
27940 0 : if (tevent_req_nomem(subreq, req)) {
27941 0 : return tevent_req_post(req, ev);
27942 : }
27943 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroupEx_done, req);
27944 0 : return req;
27945 : }
27946 :
27947 0 : static void dcerpc_clusapi_OpenGroupEx_done(struct tevent_req *subreq)
27948 : {
27949 0 : struct tevent_req *req = tevent_req_callback_data(
27950 : subreq, struct tevent_req);
27951 0 : struct dcerpc_clusapi_OpenGroupEx_state *state = tevent_req_data(
27952 : req, struct dcerpc_clusapi_OpenGroupEx_state);
27953 : NTSTATUS status;
27954 : TALLOC_CTX *mem_ctx;
27955 :
27956 0 : if (state->out_mem_ctx) {
27957 0 : mem_ctx = state->out_mem_ctx;
27958 : } else {
27959 0 : mem_ctx = state;
27960 : }
27961 :
27962 0 : status = dcerpc_clusapi_OpenGroupEx_r_recv(subreq, mem_ctx);
27963 0 : TALLOC_FREE(subreq);
27964 0 : if (tevent_req_nterror(req, status)) {
27965 0 : return;
27966 : }
27967 :
27968 : /* Copy out parameters */
27969 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
27970 0 : *state->orig.out.Status = *state->tmp.out.Status;
27971 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
27972 0 : *state->orig.out.hGroup = *state->tmp.out.hGroup;
27973 :
27974 : /* Reset temporary structure */
27975 0 : NDR_ZERO_STRUCT(state->tmp);
27976 :
27977 0 : tevent_req_done(req);
27978 : }
27979 :
27980 0 : NTSTATUS dcerpc_clusapi_OpenGroupEx_recv(struct tevent_req *req,
27981 : TALLOC_CTX *mem_ctx)
27982 : {
27983 0 : struct dcerpc_clusapi_OpenGroupEx_state *state = tevent_req_data(
27984 : req, struct dcerpc_clusapi_OpenGroupEx_state);
27985 : NTSTATUS status;
27986 :
27987 0 : if (tevent_req_is_nterror(req, &status)) {
27988 0 : tevent_req_received(req);
27989 0 : return status;
27990 : }
27991 :
27992 : /* Steal possible out parameters to the callers context */
27993 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
27994 :
27995 0 : tevent_req_received(req);
27996 0 : return NT_STATUS_OK;
27997 : }
27998 :
27999 0 : NTSTATUS dcerpc_clusapi_OpenGroupEx(struct dcerpc_binding_handle *h,
28000 : TALLOC_CTX *mem_ctx,
28001 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
28002 : uint32_t _dwDesiredAccess /* [in] */,
28003 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28004 : WERROR *_Status /* [out] [ref] */,
28005 : WERROR *_rpc_status /* [out] [ref] */,
28006 : struct policy_handle *_hGroup /* [out] [ref] */)
28007 : {
28008 : struct clusapi_OpenGroupEx r;
28009 : NTSTATUS status;
28010 :
28011 : /* In parameters */
28012 0 : r.in.lpszGroupName = _lpszGroupName;
28013 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
28014 :
28015 : /* Out parameters */
28016 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28017 0 : r.out.Status = _Status;
28018 0 : r.out.rpc_status = _rpc_status;
28019 0 : r.out.hGroup = _hGroup;
28020 :
28021 0 : status = dcerpc_clusapi_OpenGroupEx_r(h, mem_ctx, &r);
28022 0 : if (!NT_STATUS_IS_OK(status)) {
28023 0 : return status;
28024 : }
28025 :
28026 : /* Return variables */
28027 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
28028 0 : *_Status = *r.out.Status;
28029 0 : *_rpc_status = *r.out.rpc_status;
28030 0 : *_hGroup = *r.out.hGroup;
28031 :
28032 : /* Return result */
28033 :
28034 0 : return NT_STATUS_OK;
28035 : }
28036 :
28037 : struct dcerpc_clusapi_OpenResourceEx_r_state {
28038 : TALLOC_CTX *out_mem_ctx;
28039 : };
28040 :
28041 : static void dcerpc_clusapi_OpenResourceEx_r_done(struct tevent_req *subreq);
28042 :
28043 0 : struct tevent_req *dcerpc_clusapi_OpenResourceEx_r_send(TALLOC_CTX *mem_ctx,
28044 : struct tevent_context *ev,
28045 : struct dcerpc_binding_handle *h,
28046 : struct clusapi_OpenResourceEx *r)
28047 : {
28048 : struct tevent_req *req;
28049 : struct dcerpc_clusapi_OpenResourceEx_r_state *state;
28050 : struct tevent_req *subreq;
28051 :
28052 0 : req = tevent_req_create(mem_ctx, &state,
28053 : struct dcerpc_clusapi_OpenResourceEx_r_state);
28054 0 : if (req == NULL) {
28055 0 : return NULL;
28056 : }
28057 :
28058 0 : state->out_mem_ctx = talloc_new(state);
28059 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28060 0 : return tevent_req_post(req, ev);
28061 : }
28062 :
28063 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
28064 : NULL, &ndr_table_clusapi,
28065 0 : NDR_CLUSAPI_OPENRESOURCEEX, state->out_mem_ctx, r);
28066 0 : if (tevent_req_nomem(subreq, req)) {
28067 0 : return tevent_req_post(req, ev);
28068 : }
28069 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenResourceEx_r_done, req);
28070 :
28071 0 : return req;
28072 : }
28073 :
28074 0 : static void dcerpc_clusapi_OpenResourceEx_r_done(struct tevent_req *subreq)
28075 : {
28076 0 : struct tevent_req *req =
28077 0 : tevent_req_callback_data(subreq,
28078 : struct tevent_req);
28079 : NTSTATUS status;
28080 :
28081 0 : status = dcerpc_binding_handle_call_recv(subreq);
28082 0 : TALLOC_FREE(subreq);
28083 0 : if (tevent_req_nterror(req, status)) {
28084 0 : return;
28085 : }
28086 :
28087 0 : tevent_req_done(req);
28088 : }
28089 :
28090 0 : NTSTATUS dcerpc_clusapi_OpenResourceEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
28091 : {
28092 0 : struct dcerpc_clusapi_OpenResourceEx_r_state *state =
28093 0 : tevent_req_data(req,
28094 : struct dcerpc_clusapi_OpenResourceEx_r_state);
28095 : NTSTATUS status;
28096 :
28097 0 : if (tevent_req_is_nterror(req, &status)) {
28098 0 : tevent_req_received(req);
28099 0 : return status;
28100 : }
28101 :
28102 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28103 :
28104 0 : tevent_req_received(req);
28105 0 : return NT_STATUS_OK;
28106 : }
28107 :
28108 0 : NTSTATUS dcerpc_clusapi_OpenResourceEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenResourceEx *r)
28109 : {
28110 : NTSTATUS status;
28111 :
28112 0 : status = dcerpc_binding_handle_call(h,
28113 : NULL, &ndr_table_clusapi,
28114 : NDR_CLUSAPI_OPENRESOURCEEX, mem_ctx, r);
28115 :
28116 0 : return status;
28117 : }
28118 :
28119 : struct dcerpc_clusapi_OpenResourceEx_state {
28120 : struct clusapi_OpenResourceEx orig;
28121 : struct clusapi_OpenResourceEx tmp;
28122 : TALLOC_CTX *out_mem_ctx;
28123 : };
28124 :
28125 : static void dcerpc_clusapi_OpenResourceEx_done(struct tevent_req *subreq);
28126 :
28127 0 : struct tevent_req *dcerpc_clusapi_OpenResourceEx_send(TALLOC_CTX *mem_ctx,
28128 : struct tevent_context *ev,
28129 : struct dcerpc_binding_handle *h,
28130 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
28131 : uint32_t _dwDesiredAccess /* [in] */,
28132 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28133 : WERROR *_Status /* [out] [ref] */,
28134 : WERROR *_rpc_status /* [out] [ref] */,
28135 : struct policy_handle *_hResource /* [out] [ref] */)
28136 : {
28137 : struct tevent_req *req;
28138 : struct dcerpc_clusapi_OpenResourceEx_state *state;
28139 : struct tevent_req *subreq;
28140 :
28141 0 : req = tevent_req_create(mem_ctx, &state,
28142 : struct dcerpc_clusapi_OpenResourceEx_state);
28143 0 : if (req == NULL) {
28144 0 : return NULL;
28145 : }
28146 0 : state->out_mem_ctx = NULL;
28147 :
28148 : /* In parameters */
28149 0 : state->orig.in.lpszResourceName = _lpszResourceName;
28150 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
28151 :
28152 : /* Out parameters */
28153 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28154 0 : state->orig.out.Status = _Status;
28155 0 : state->orig.out.rpc_status = _rpc_status;
28156 0 : state->orig.out.hResource = _hResource;
28157 :
28158 0 : state->out_mem_ctx = talloc_named_const(state, 0,
28159 : "dcerpc_clusapi_OpenResourceEx_out_memory");
28160 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28161 0 : return tevent_req_post(req, ev);
28162 : }
28163 :
28164 : /* make a temporary copy, that we pass to the dispatch function */
28165 0 : state->tmp = state->orig;
28166 :
28167 0 : subreq = dcerpc_clusapi_OpenResourceEx_r_send(state, ev, h, &state->tmp);
28168 0 : if (tevent_req_nomem(subreq, req)) {
28169 0 : return tevent_req_post(req, ev);
28170 : }
28171 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenResourceEx_done, req);
28172 0 : return req;
28173 : }
28174 :
28175 0 : static void dcerpc_clusapi_OpenResourceEx_done(struct tevent_req *subreq)
28176 : {
28177 0 : struct tevent_req *req = tevent_req_callback_data(
28178 : subreq, struct tevent_req);
28179 0 : struct dcerpc_clusapi_OpenResourceEx_state *state = tevent_req_data(
28180 : req, struct dcerpc_clusapi_OpenResourceEx_state);
28181 : NTSTATUS status;
28182 : TALLOC_CTX *mem_ctx;
28183 :
28184 0 : if (state->out_mem_ctx) {
28185 0 : mem_ctx = state->out_mem_ctx;
28186 : } else {
28187 0 : mem_ctx = state;
28188 : }
28189 :
28190 0 : status = dcerpc_clusapi_OpenResourceEx_r_recv(subreq, mem_ctx);
28191 0 : TALLOC_FREE(subreq);
28192 0 : if (tevent_req_nterror(req, status)) {
28193 0 : return;
28194 : }
28195 :
28196 : /* Copy out parameters */
28197 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
28198 0 : *state->orig.out.Status = *state->tmp.out.Status;
28199 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
28200 0 : *state->orig.out.hResource = *state->tmp.out.hResource;
28201 :
28202 : /* Reset temporary structure */
28203 0 : NDR_ZERO_STRUCT(state->tmp);
28204 :
28205 0 : tevent_req_done(req);
28206 : }
28207 :
28208 0 : NTSTATUS dcerpc_clusapi_OpenResourceEx_recv(struct tevent_req *req,
28209 : TALLOC_CTX *mem_ctx)
28210 : {
28211 0 : struct dcerpc_clusapi_OpenResourceEx_state *state = tevent_req_data(
28212 : req, struct dcerpc_clusapi_OpenResourceEx_state);
28213 : NTSTATUS status;
28214 :
28215 0 : if (tevent_req_is_nterror(req, &status)) {
28216 0 : tevent_req_received(req);
28217 0 : return status;
28218 : }
28219 :
28220 : /* Steal possible out parameters to the callers context */
28221 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28222 :
28223 0 : tevent_req_received(req);
28224 0 : return NT_STATUS_OK;
28225 : }
28226 :
28227 0 : NTSTATUS dcerpc_clusapi_OpenResourceEx(struct dcerpc_binding_handle *h,
28228 : TALLOC_CTX *mem_ctx,
28229 : const char *_lpszResourceName /* [in] [charset(UTF16),ref] */,
28230 : uint32_t _dwDesiredAccess /* [in] */,
28231 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28232 : WERROR *_Status /* [out] [ref] */,
28233 : WERROR *_rpc_status /* [out] [ref] */,
28234 : struct policy_handle *_hResource /* [out] [ref] */)
28235 : {
28236 : struct clusapi_OpenResourceEx r;
28237 : NTSTATUS status;
28238 :
28239 : /* In parameters */
28240 0 : r.in.lpszResourceName = _lpszResourceName;
28241 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
28242 :
28243 : /* Out parameters */
28244 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28245 0 : r.out.Status = _Status;
28246 0 : r.out.rpc_status = _rpc_status;
28247 0 : r.out.hResource = _hResource;
28248 :
28249 0 : status = dcerpc_clusapi_OpenResourceEx_r(h, mem_ctx, &r);
28250 0 : if (!NT_STATUS_IS_OK(status)) {
28251 0 : return status;
28252 : }
28253 :
28254 : /* Return variables */
28255 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
28256 0 : *_Status = *r.out.Status;
28257 0 : *_rpc_status = *r.out.rpc_status;
28258 0 : *_hResource = *r.out.hResource;
28259 :
28260 : /* Return result */
28261 :
28262 0 : return NT_STATUS_OK;
28263 : }
28264 :
28265 : struct dcerpc_clusapi_OpenNetworkEx_r_state {
28266 : TALLOC_CTX *out_mem_ctx;
28267 : };
28268 :
28269 : static void dcerpc_clusapi_OpenNetworkEx_r_done(struct tevent_req *subreq);
28270 :
28271 0 : struct tevent_req *dcerpc_clusapi_OpenNetworkEx_r_send(TALLOC_CTX *mem_ctx,
28272 : struct tevent_context *ev,
28273 : struct dcerpc_binding_handle *h,
28274 : struct clusapi_OpenNetworkEx *r)
28275 : {
28276 : struct tevent_req *req;
28277 : struct dcerpc_clusapi_OpenNetworkEx_r_state *state;
28278 : struct tevent_req *subreq;
28279 :
28280 0 : req = tevent_req_create(mem_ctx, &state,
28281 : struct dcerpc_clusapi_OpenNetworkEx_r_state);
28282 0 : if (req == NULL) {
28283 0 : return NULL;
28284 : }
28285 :
28286 0 : state->out_mem_ctx = talloc_new(state);
28287 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28288 0 : return tevent_req_post(req, ev);
28289 : }
28290 :
28291 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
28292 : NULL, &ndr_table_clusapi,
28293 0 : NDR_CLUSAPI_OPENNETWORKEX, state->out_mem_ctx, r);
28294 0 : if (tevent_req_nomem(subreq, req)) {
28295 0 : return tevent_req_post(req, ev);
28296 : }
28297 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetworkEx_r_done, req);
28298 :
28299 0 : return req;
28300 : }
28301 :
28302 0 : static void dcerpc_clusapi_OpenNetworkEx_r_done(struct tevent_req *subreq)
28303 : {
28304 0 : struct tevent_req *req =
28305 0 : tevent_req_callback_data(subreq,
28306 : struct tevent_req);
28307 : NTSTATUS status;
28308 :
28309 0 : status = dcerpc_binding_handle_call_recv(subreq);
28310 0 : TALLOC_FREE(subreq);
28311 0 : if (tevent_req_nterror(req, status)) {
28312 0 : return;
28313 : }
28314 :
28315 0 : tevent_req_done(req);
28316 : }
28317 :
28318 0 : NTSTATUS dcerpc_clusapi_OpenNetworkEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
28319 : {
28320 0 : struct dcerpc_clusapi_OpenNetworkEx_r_state *state =
28321 0 : tevent_req_data(req,
28322 : struct dcerpc_clusapi_OpenNetworkEx_r_state);
28323 : NTSTATUS status;
28324 :
28325 0 : if (tevent_req_is_nterror(req, &status)) {
28326 0 : tevent_req_received(req);
28327 0 : return status;
28328 : }
28329 :
28330 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28331 :
28332 0 : tevent_req_received(req);
28333 0 : return NT_STATUS_OK;
28334 : }
28335 :
28336 0 : NTSTATUS dcerpc_clusapi_OpenNetworkEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNetworkEx *r)
28337 : {
28338 : NTSTATUS status;
28339 :
28340 0 : status = dcerpc_binding_handle_call(h,
28341 : NULL, &ndr_table_clusapi,
28342 : NDR_CLUSAPI_OPENNETWORKEX, mem_ctx, r);
28343 :
28344 0 : return status;
28345 : }
28346 :
28347 : struct dcerpc_clusapi_OpenNetworkEx_state {
28348 : struct clusapi_OpenNetworkEx orig;
28349 : struct clusapi_OpenNetworkEx tmp;
28350 : TALLOC_CTX *out_mem_ctx;
28351 : };
28352 :
28353 : static void dcerpc_clusapi_OpenNetworkEx_done(struct tevent_req *subreq);
28354 :
28355 0 : struct tevent_req *dcerpc_clusapi_OpenNetworkEx_send(TALLOC_CTX *mem_ctx,
28356 : struct tevent_context *ev,
28357 : struct dcerpc_binding_handle *h,
28358 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
28359 : uint32_t _dwDesiredAccess /* [in] */,
28360 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28361 : WERROR *_Status /* [out] [ref] */,
28362 : WERROR *_rpc_status /* [out] [ref] */,
28363 : struct policy_handle *_hNetwork /* [out] [ref] */)
28364 : {
28365 : struct tevent_req *req;
28366 : struct dcerpc_clusapi_OpenNetworkEx_state *state;
28367 : struct tevent_req *subreq;
28368 :
28369 0 : req = tevent_req_create(mem_ctx, &state,
28370 : struct dcerpc_clusapi_OpenNetworkEx_state);
28371 0 : if (req == NULL) {
28372 0 : return NULL;
28373 : }
28374 0 : state->out_mem_ctx = NULL;
28375 :
28376 : /* In parameters */
28377 0 : state->orig.in.lpszNetworkName = _lpszNetworkName;
28378 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
28379 :
28380 : /* Out parameters */
28381 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28382 0 : state->orig.out.Status = _Status;
28383 0 : state->orig.out.rpc_status = _rpc_status;
28384 0 : state->orig.out.hNetwork = _hNetwork;
28385 :
28386 0 : state->out_mem_ctx = talloc_named_const(state, 0,
28387 : "dcerpc_clusapi_OpenNetworkEx_out_memory");
28388 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28389 0 : return tevent_req_post(req, ev);
28390 : }
28391 :
28392 : /* make a temporary copy, that we pass to the dispatch function */
28393 0 : state->tmp = state->orig;
28394 :
28395 0 : subreq = dcerpc_clusapi_OpenNetworkEx_r_send(state, ev, h, &state->tmp);
28396 0 : if (tevent_req_nomem(subreq, req)) {
28397 0 : return tevent_req_post(req, ev);
28398 : }
28399 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetworkEx_done, req);
28400 0 : return req;
28401 : }
28402 :
28403 0 : static void dcerpc_clusapi_OpenNetworkEx_done(struct tevent_req *subreq)
28404 : {
28405 0 : struct tevent_req *req = tevent_req_callback_data(
28406 : subreq, struct tevent_req);
28407 0 : struct dcerpc_clusapi_OpenNetworkEx_state *state = tevent_req_data(
28408 : req, struct dcerpc_clusapi_OpenNetworkEx_state);
28409 : NTSTATUS status;
28410 : TALLOC_CTX *mem_ctx;
28411 :
28412 0 : if (state->out_mem_ctx) {
28413 0 : mem_ctx = state->out_mem_ctx;
28414 : } else {
28415 0 : mem_ctx = state;
28416 : }
28417 :
28418 0 : status = dcerpc_clusapi_OpenNetworkEx_r_recv(subreq, mem_ctx);
28419 0 : TALLOC_FREE(subreq);
28420 0 : if (tevent_req_nterror(req, status)) {
28421 0 : return;
28422 : }
28423 :
28424 : /* Copy out parameters */
28425 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
28426 0 : *state->orig.out.Status = *state->tmp.out.Status;
28427 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
28428 0 : *state->orig.out.hNetwork = *state->tmp.out.hNetwork;
28429 :
28430 : /* Reset temporary structure */
28431 0 : NDR_ZERO_STRUCT(state->tmp);
28432 :
28433 0 : tevent_req_done(req);
28434 : }
28435 :
28436 0 : NTSTATUS dcerpc_clusapi_OpenNetworkEx_recv(struct tevent_req *req,
28437 : TALLOC_CTX *mem_ctx)
28438 : {
28439 0 : struct dcerpc_clusapi_OpenNetworkEx_state *state = tevent_req_data(
28440 : req, struct dcerpc_clusapi_OpenNetworkEx_state);
28441 : NTSTATUS status;
28442 :
28443 0 : if (tevent_req_is_nterror(req, &status)) {
28444 0 : tevent_req_received(req);
28445 0 : return status;
28446 : }
28447 :
28448 : /* Steal possible out parameters to the callers context */
28449 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28450 :
28451 0 : tevent_req_received(req);
28452 0 : return NT_STATUS_OK;
28453 : }
28454 :
28455 0 : NTSTATUS dcerpc_clusapi_OpenNetworkEx(struct dcerpc_binding_handle *h,
28456 : TALLOC_CTX *mem_ctx,
28457 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
28458 : uint32_t _dwDesiredAccess /* [in] */,
28459 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28460 : WERROR *_Status /* [out] [ref] */,
28461 : WERROR *_rpc_status /* [out] [ref] */,
28462 : struct policy_handle *_hNetwork /* [out] [ref] */)
28463 : {
28464 : struct clusapi_OpenNetworkEx r;
28465 : NTSTATUS status;
28466 :
28467 : /* In parameters */
28468 0 : r.in.lpszNetworkName = _lpszNetworkName;
28469 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
28470 :
28471 : /* Out parameters */
28472 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28473 0 : r.out.Status = _Status;
28474 0 : r.out.rpc_status = _rpc_status;
28475 0 : r.out.hNetwork = _hNetwork;
28476 :
28477 0 : status = dcerpc_clusapi_OpenNetworkEx_r(h, mem_ctx, &r);
28478 0 : if (!NT_STATUS_IS_OK(status)) {
28479 0 : return status;
28480 : }
28481 :
28482 : /* Return variables */
28483 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
28484 0 : *_Status = *r.out.Status;
28485 0 : *_rpc_status = *r.out.rpc_status;
28486 0 : *_hNetwork = *r.out.hNetwork;
28487 :
28488 : /* Return result */
28489 :
28490 0 : return NT_STATUS_OK;
28491 : }
28492 :
28493 : struct dcerpc_clusapi_OpenNetInterfaceEx_r_state {
28494 : TALLOC_CTX *out_mem_ctx;
28495 : };
28496 :
28497 : static void dcerpc_clusapi_OpenNetInterfaceEx_r_done(struct tevent_req *subreq);
28498 :
28499 0 : struct tevent_req *dcerpc_clusapi_OpenNetInterfaceEx_r_send(TALLOC_CTX *mem_ctx,
28500 : struct tevent_context *ev,
28501 : struct dcerpc_binding_handle *h,
28502 : struct clusapi_OpenNetInterfaceEx *r)
28503 : {
28504 : struct tevent_req *req;
28505 : struct dcerpc_clusapi_OpenNetInterfaceEx_r_state *state;
28506 : struct tevent_req *subreq;
28507 :
28508 0 : req = tevent_req_create(mem_ctx, &state,
28509 : struct dcerpc_clusapi_OpenNetInterfaceEx_r_state);
28510 0 : if (req == NULL) {
28511 0 : return NULL;
28512 : }
28513 :
28514 0 : state->out_mem_ctx = talloc_new(state);
28515 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28516 0 : return tevent_req_post(req, ev);
28517 : }
28518 :
28519 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
28520 : NULL, &ndr_table_clusapi,
28521 0 : NDR_CLUSAPI_OPENNETINTERFACEEX, state->out_mem_ctx, r);
28522 0 : if (tevent_req_nomem(subreq, req)) {
28523 0 : return tevent_req_post(req, ev);
28524 : }
28525 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetInterfaceEx_r_done, req);
28526 :
28527 0 : return req;
28528 : }
28529 :
28530 0 : static void dcerpc_clusapi_OpenNetInterfaceEx_r_done(struct tevent_req *subreq)
28531 : {
28532 0 : struct tevent_req *req =
28533 0 : tevent_req_callback_data(subreq,
28534 : struct tevent_req);
28535 : NTSTATUS status;
28536 :
28537 0 : status = dcerpc_binding_handle_call_recv(subreq);
28538 0 : TALLOC_FREE(subreq);
28539 0 : if (tevent_req_nterror(req, status)) {
28540 0 : return;
28541 : }
28542 :
28543 0 : tevent_req_done(req);
28544 : }
28545 :
28546 0 : NTSTATUS dcerpc_clusapi_OpenNetInterfaceEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
28547 : {
28548 0 : struct dcerpc_clusapi_OpenNetInterfaceEx_r_state *state =
28549 0 : tevent_req_data(req,
28550 : struct dcerpc_clusapi_OpenNetInterfaceEx_r_state);
28551 : NTSTATUS status;
28552 :
28553 0 : if (tevent_req_is_nterror(req, &status)) {
28554 0 : tevent_req_received(req);
28555 0 : return status;
28556 : }
28557 :
28558 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28559 :
28560 0 : tevent_req_received(req);
28561 0 : return NT_STATUS_OK;
28562 : }
28563 :
28564 0 : NTSTATUS dcerpc_clusapi_OpenNetInterfaceEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenNetInterfaceEx *r)
28565 : {
28566 : NTSTATUS status;
28567 :
28568 0 : status = dcerpc_binding_handle_call(h,
28569 : NULL, &ndr_table_clusapi,
28570 : NDR_CLUSAPI_OPENNETINTERFACEEX, mem_ctx, r);
28571 :
28572 0 : return status;
28573 : }
28574 :
28575 : struct dcerpc_clusapi_OpenNetInterfaceEx_state {
28576 : struct clusapi_OpenNetInterfaceEx orig;
28577 : struct clusapi_OpenNetInterfaceEx tmp;
28578 : TALLOC_CTX *out_mem_ctx;
28579 : };
28580 :
28581 : static void dcerpc_clusapi_OpenNetInterfaceEx_done(struct tevent_req *subreq);
28582 :
28583 0 : struct tevent_req *dcerpc_clusapi_OpenNetInterfaceEx_send(TALLOC_CTX *mem_ctx,
28584 : struct tevent_context *ev,
28585 : struct dcerpc_binding_handle *h,
28586 : const char *_lpszNetInterfaceName /* [in] [charset(UTF16),ref] */,
28587 : uint32_t _dwDesiredAccess /* [in] */,
28588 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28589 : WERROR *_Status /* [out] [ref] */,
28590 : WERROR *_rpc_status /* [out] [ref] */,
28591 : struct policy_handle *_hNetInterface /* [out] [ref] */)
28592 : {
28593 : struct tevent_req *req;
28594 : struct dcerpc_clusapi_OpenNetInterfaceEx_state *state;
28595 : struct tevent_req *subreq;
28596 :
28597 0 : req = tevent_req_create(mem_ctx, &state,
28598 : struct dcerpc_clusapi_OpenNetInterfaceEx_state);
28599 0 : if (req == NULL) {
28600 0 : return NULL;
28601 : }
28602 0 : state->out_mem_ctx = NULL;
28603 :
28604 : /* In parameters */
28605 0 : state->orig.in.lpszNetInterfaceName = _lpszNetInterfaceName;
28606 0 : state->orig.in.dwDesiredAccess = _dwDesiredAccess;
28607 :
28608 : /* Out parameters */
28609 0 : state->orig.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28610 0 : state->orig.out.Status = _Status;
28611 0 : state->orig.out.rpc_status = _rpc_status;
28612 0 : state->orig.out.hNetInterface = _hNetInterface;
28613 :
28614 0 : state->out_mem_ctx = talloc_named_const(state, 0,
28615 : "dcerpc_clusapi_OpenNetInterfaceEx_out_memory");
28616 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28617 0 : return tevent_req_post(req, ev);
28618 : }
28619 :
28620 : /* make a temporary copy, that we pass to the dispatch function */
28621 0 : state->tmp = state->orig;
28622 :
28623 0 : subreq = dcerpc_clusapi_OpenNetInterfaceEx_r_send(state, ev, h, &state->tmp);
28624 0 : if (tevent_req_nomem(subreq, req)) {
28625 0 : return tevent_req_post(req, ev);
28626 : }
28627 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenNetInterfaceEx_done, req);
28628 0 : return req;
28629 : }
28630 :
28631 0 : static void dcerpc_clusapi_OpenNetInterfaceEx_done(struct tevent_req *subreq)
28632 : {
28633 0 : struct tevent_req *req = tevent_req_callback_data(
28634 : subreq, struct tevent_req);
28635 0 : struct dcerpc_clusapi_OpenNetInterfaceEx_state *state = tevent_req_data(
28636 : req, struct dcerpc_clusapi_OpenNetInterfaceEx_state);
28637 : NTSTATUS status;
28638 : TALLOC_CTX *mem_ctx;
28639 :
28640 0 : if (state->out_mem_ctx) {
28641 0 : mem_ctx = state->out_mem_ctx;
28642 : } else {
28643 0 : mem_ctx = state;
28644 : }
28645 :
28646 0 : status = dcerpc_clusapi_OpenNetInterfaceEx_r_recv(subreq, mem_ctx);
28647 0 : TALLOC_FREE(subreq);
28648 0 : if (tevent_req_nterror(req, status)) {
28649 0 : return;
28650 : }
28651 :
28652 : /* Copy out parameters */
28653 0 : *state->orig.out.lpdwGrantedAccess = *state->tmp.out.lpdwGrantedAccess;
28654 0 : *state->orig.out.Status = *state->tmp.out.Status;
28655 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
28656 0 : *state->orig.out.hNetInterface = *state->tmp.out.hNetInterface;
28657 :
28658 : /* Reset temporary structure */
28659 0 : NDR_ZERO_STRUCT(state->tmp);
28660 :
28661 0 : tevent_req_done(req);
28662 : }
28663 :
28664 0 : NTSTATUS dcerpc_clusapi_OpenNetInterfaceEx_recv(struct tevent_req *req,
28665 : TALLOC_CTX *mem_ctx)
28666 : {
28667 0 : struct dcerpc_clusapi_OpenNetInterfaceEx_state *state = tevent_req_data(
28668 : req, struct dcerpc_clusapi_OpenNetInterfaceEx_state);
28669 : NTSTATUS status;
28670 :
28671 0 : if (tevent_req_is_nterror(req, &status)) {
28672 0 : tevent_req_received(req);
28673 0 : return status;
28674 : }
28675 :
28676 : /* Steal possible out parameters to the callers context */
28677 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28678 :
28679 0 : tevent_req_received(req);
28680 0 : return NT_STATUS_OK;
28681 : }
28682 :
28683 0 : NTSTATUS dcerpc_clusapi_OpenNetInterfaceEx(struct dcerpc_binding_handle *h,
28684 : TALLOC_CTX *mem_ctx,
28685 : const char *_lpszNetInterfaceName /* [in] [charset(UTF16),ref] */,
28686 : uint32_t _dwDesiredAccess /* [in] */,
28687 : uint32_t *_lpdwGrantedAccess /* [out] [ref] */,
28688 : WERROR *_Status /* [out] [ref] */,
28689 : WERROR *_rpc_status /* [out] [ref] */,
28690 : struct policy_handle *_hNetInterface /* [out] [ref] */)
28691 : {
28692 : struct clusapi_OpenNetInterfaceEx r;
28693 : NTSTATUS status;
28694 :
28695 : /* In parameters */
28696 0 : r.in.lpszNetInterfaceName = _lpszNetInterfaceName;
28697 0 : r.in.dwDesiredAccess = _dwDesiredAccess;
28698 :
28699 : /* Out parameters */
28700 0 : r.out.lpdwGrantedAccess = _lpdwGrantedAccess;
28701 0 : r.out.Status = _Status;
28702 0 : r.out.rpc_status = _rpc_status;
28703 0 : r.out.hNetInterface = _hNetInterface;
28704 :
28705 0 : status = dcerpc_clusapi_OpenNetInterfaceEx_r(h, mem_ctx, &r);
28706 0 : if (!NT_STATUS_IS_OK(status)) {
28707 0 : return status;
28708 : }
28709 :
28710 : /* Return variables */
28711 0 : *_lpdwGrantedAccess = *r.out.lpdwGrantedAccess;
28712 0 : *_Status = *r.out.Status;
28713 0 : *_rpc_status = *r.out.rpc_status;
28714 0 : *_hNetInterface = *r.out.hNetInterface;
28715 :
28716 : /* Return result */
28717 :
28718 0 : return NT_STATUS_OK;
28719 : }
28720 :
28721 : struct dcerpc_clusapi_ChangeCsvState_r_state {
28722 : TALLOC_CTX *out_mem_ctx;
28723 : };
28724 :
28725 : static void dcerpc_clusapi_ChangeCsvState_r_done(struct tevent_req *subreq);
28726 :
28727 0 : struct tevent_req *dcerpc_clusapi_ChangeCsvState_r_send(TALLOC_CTX *mem_ctx,
28728 : struct tevent_context *ev,
28729 : struct dcerpc_binding_handle *h,
28730 : struct clusapi_ChangeCsvState *r)
28731 : {
28732 : struct tevent_req *req;
28733 : struct dcerpc_clusapi_ChangeCsvState_r_state *state;
28734 : struct tevent_req *subreq;
28735 :
28736 0 : req = tevent_req_create(mem_ctx, &state,
28737 : struct dcerpc_clusapi_ChangeCsvState_r_state);
28738 0 : if (req == NULL) {
28739 0 : return NULL;
28740 : }
28741 :
28742 0 : state->out_mem_ctx = talloc_new(state);
28743 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28744 0 : return tevent_req_post(req, ev);
28745 : }
28746 :
28747 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
28748 : NULL, &ndr_table_clusapi,
28749 0 : NDR_CLUSAPI_CHANGECSVSTATE, state->out_mem_ctx, r);
28750 0 : if (tevent_req_nomem(subreq, req)) {
28751 0 : return tevent_req_post(req, ev);
28752 : }
28753 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeCsvState_r_done, req);
28754 :
28755 0 : return req;
28756 : }
28757 :
28758 0 : static void dcerpc_clusapi_ChangeCsvState_r_done(struct tevent_req *subreq)
28759 : {
28760 0 : struct tevent_req *req =
28761 0 : tevent_req_callback_data(subreq,
28762 : struct tevent_req);
28763 : NTSTATUS status;
28764 :
28765 0 : status = dcerpc_binding_handle_call_recv(subreq);
28766 0 : TALLOC_FREE(subreq);
28767 0 : if (tevent_req_nterror(req, status)) {
28768 0 : return;
28769 : }
28770 :
28771 0 : tevent_req_done(req);
28772 : }
28773 :
28774 0 : NTSTATUS dcerpc_clusapi_ChangeCsvState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
28775 : {
28776 0 : struct dcerpc_clusapi_ChangeCsvState_r_state *state =
28777 0 : tevent_req_data(req,
28778 : struct dcerpc_clusapi_ChangeCsvState_r_state);
28779 : NTSTATUS status;
28780 :
28781 0 : if (tevent_req_is_nterror(req, &status)) {
28782 0 : tevent_req_received(req);
28783 0 : return status;
28784 : }
28785 :
28786 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28787 :
28788 0 : tevent_req_received(req);
28789 0 : return NT_STATUS_OK;
28790 : }
28791 :
28792 0 : NTSTATUS dcerpc_clusapi_ChangeCsvState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ChangeCsvState *r)
28793 : {
28794 : NTSTATUS status;
28795 :
28796 0 : status = dcerpc_binding_handle_call(h,
28797 : NULL, &ndr_table_clusapi,
28798 : NDR_CLUSAPI_CHANGECSVSTATE, mem_ctx, r);
28799 :
28800 0 : return status;
28801 : }
28802 :
28803 : struct dcerpc_clusapi_ChangeCsvState_state {
28804 : struct clusapi_ChangeCsvState orig;
28805 : struct clusapi_ChangeCsvState tmp;
28806 : TALLOC_CTX *out_mem_ctx;
28807 : };
28808 :
28809 : static void dcerpc_clusapi_ChangeCsvState_done(struct tevent_req *subreq);
28810 :
28811 0 : struct tevent_req *dcerpc_clusapi_ChangeCsvState_send(TALLOC_CTX *mem_ctx,
28812 : struct tevent_context *ev,
28813 : struct dcerpc_binding_handle *h,
28814 : struct policy_handle _hResource /* [in] */,
28815 : uint32_t _dwState /* [in] */,
28816 : WERROR *_rpc_status /* [out] [ref] */)
28817 : {
28818 : struct tevent_req *req;
28819 : struct dcerpc_clusapi_ChangeCsvState_state *state;
28820 : struct tevent_req *subreq;
28821 :
28822 0 : req = tevent_req_create(mem_ctx, &state,
28823 : struct dcerpc_clusapi_ChangeCsvState_state);
28824 0 : if (req == NULL) {
28825 0 : return NULL;
28826 : }
28827 0 : state->out_mem_ctx = NULL;
28828 :
28829 : /* In parameters */
28830 0 : state->orig.in.hResource = _hResource;
28831 0 : state->orig.in.dwState = _dwState;
28832 :
28833 : /* Out parameters */
28834 0 : state->orig.out.rpc_status = _rpc_status;
28835 :
28836 : /* Result */
28837 0 : NDR_ZERO_STRUCT(state->orig.out.result);
28838 :
28839 0 : state->out_mem_ctx = talloc_named_const(state, 0,
28840 : "dcerpc_clusapi_ChangeCsvState_out_memory");
28841 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28842 0 : return tevent_req_post(req, ev);
28843 : }
28844 :
28845 : /* make a temporary copy, that we pass to the dispatch function */
28846 0 : state->tmp = state->orig;
28847 :
28848 0 : subreq = dcerpc_clusapi_ChangeCsvState_r_send(state, ev, h, &state->tmp);
28849 0 : if (tevent_req_nomem(subreq, req)) {
28850 0 : return tevent_req_post(req, ev);
28851 : }
28852 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeCsvState_done, req);
28853 0 : return req;
28854 : }
28855 :
28856 0 : static void dcerpc_clusapi_ChangeCsvState_done(struct tevent_req *subreq)
28857 : {
28858 0 : struct tevent_req *req = tevent_req_callback_data(
28859 : subreq, struct tevent_req);
28860 0 : struct dcerpc_clusapi_ChangeCsvState_state *state = tevent_req_data(
28861 : req, struct dcerpc_clusapi_ChangeCsvState_state);
28862 : NTSTATUS status;
28863 : TALLOC_CTX *mem_ctx;
28864 :
28865 0 : if (state->out_mem_ctx) {
28866 0 : mem_ctx = state->out_mem_ctx;
28867 : } else {
28868 0 : mem_ctx = state;
28869 : }
28870 :
28871 0 : status = dcerpc_clusapi_ChangeCsvState_r_recv(subreq, mem_ctx);
28872 0 : TALLOC_FREE(subreq);
28873 0 : if (tevent_req_nterror(req, status)) {
28874 0 : return;
28875 : }
28876 :
28877 : /* Copy out parameters */
28878 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
28879 :
28880 : /* Copy result */
28881 0 : state->orig.out.result = state->tmp.out.result;
28882 :
28883 : /* Reset temporary structure */
28884 0 : NDR_ZERO_STRUCT(state->tmp);
28885 :
28886 0 : tevent_req_done(req);
28887 : }
28888 :
28889 0 : NTSTATUS dcerpc_clusapi_ChangeCsvState_recv(struct tevent_req *req,
28890 : TALLOC_CTX *mem_ctx,
28891 : WERROR *result)
28892 : {
28893 0 : struct dcerpc_clusapi_ChangeCsvState_state *state = tevent_req_data(
28894 : req, struct dcerpc_clusapi_ChangeCsvState_state);
28895 : NTSTATUS status;
28896 :
28897 0 : if (tevent_req_is_nterror(req, &status)) {
28898 0 : tevent_req_received(req);
28899 0 : return status;
28900 : }
28901 :
28902 : /* Steal possible out parameters to the callers context */
28903 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
28904 :
28905 : /* Return result */
28906 0 : *result = state->orig.out.result;
28907 :
28908 0 : tevent_req_received(req);
28909 0 : return NT_STATUS_OK;
28910 : }
28911 :
28912 0 : NTSTATUS dcerpc_clusapi_ChangeCsvState(struct dcerpc_binding_handle *h,
28913 : TALLOC_CTX *mem_ctx,
28914 : struct policy_handle _hResource /* [in] */,
28915 : uint32_t _dwState /* [in] */,
28916 : WERROR *_rpc_status /* [out] [ref] */,
28917 : WERROR *result)
28918 : {
28919 : struct clusapi_ChangeCsvState r;
28920 : NTSTATUS status;
28921 :
28922 : /* In parameters */
28923 0 : r.in.hResource = _hResource;
28924 0 : r.in.dwState = _dwState;
28925 :
28926 : /* Out parameters */
28927 0 : r.out.rpc_status = _rpc_status;
28928 :
28929 : /* Result */
28930 0 : NDR_ZERO_STRUCT(r.out.result);
28931 :
28932 0 : status = dcerpc_clusapi_ChangeCsvState_r(h, mem_ctx, &r);
28933 0 : if (!NT_STATUS_IS_OK(status)) {
28934 0 : return status;
28935 : }
28936 :
28937 : /* Return variables */
28938 0 : *_rpc_status = *r.out.rpc_status;
28939 :
28940 : /* Return result */
28941 0 : *result = r.out.result;
28942 :
28943 0 : return NT_STATUS_OK;
28944 : }
28945 :
28946 : struct dcerpc_clusapi_CreateNodeEnumEx_r_state {
28947 : TALLOC_CTX *out_mem_ctx;
28948 : };
28949 :
28950 : static void dcerpc_clusapi_CreateNodeEnumEx_r_done(struct tevent_req *subreq);
28951 :
28952 0 : struct tevent_req *dcerpc_clusapi_CreateNodeEnumEx_r_send(TALLOC_CTX *mem_ctx,
28953 : struct tevent_context *ev,
28954 : struct dcerpc_binding_handle *h,
28955 : struct clusapi_CreateNodeEnumEx *r)
28956 : {
28957 : struct tevent_req *req;
28958 : struct dcerpc_clusapi_CreateNodeEnumEx_r_state *state;
28959 : struct tevent_req *subreq;
28960 :
28961 0 : req = tevent_req_create(mem_ctx, &state,
28962 : struct dcerpc_clusapi_CreateNodeEnumEx_r_state);
28963 0 : if (req == NULL) {
28964 0 : return NULL;
28965 : }
28966 :
28967 0 : state->out_mem_ctx = talloc_new(state);
28968 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
28969 0 : return tevent_req_post(req, ev);
28970 : }
28971 :
28972 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
28973 : NULL, &ndr_table_clusapi,
28974 0 : NDR_CLUSAPI_CREATENODEENUMEX, state->out_mem_ctx, r);
28975 0 : if (tevent_req_nomem(subreq, req)) {
28976 0 : return tevent_req_post(req, ev);
28977 : }
28978 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNodeEnumEx_r_done, req);
28979 :
28980 0 : return req;
28981 : }
28982 :
28983 0 : static void dcerpc_clusapi_CreateNodeEnumEx_r_done(struct tevent_req *subreq)
28984 : {
28985 0 : struct tevent_req *req =
28986 0 : tevent_req_callback_data(subreq,
28987 : struct tevent_req);
28988 : NTSTATUS status;
28989 :
28990 0 : status = dcerpc_binding_handle_call_recv(subreq);
28991 0 : TALLOC_FREE(subreq);
28992 0 : if (tevent_req_nterror(req, status)) {
28993 0 : return;
28994 : }
28995 :
28996 0 : tevent_req_done(req);
28997 : }
28998 :
28999 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnumEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
29000 : {
29001 0 : struct dcerpc_clusapi_CreateNodeEnumEx_r_state *state =
29002 0 : tevent_req_data(req,
29003 : struct dcerpc_clusapi_CreateNodeEnumEx_r_state);
29004 : NTSTATUS status;
29005 :
29006 0 : if (tevent_req_is_nterror(req, &status)) {
29007 0 : tevent_req_received(req);
29008 0 : return status;
29009 : }
29010 :
29011 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29012 :
29013 0 : tevent_req_received(req);
29014 0 : return NT_STATUS_OK;
29015 : }
29016 :
29017 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnumEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNodeEnumEx *r)
29018 : {
29019 : NTSTATUS status;
29020 :
29021 0 : status = dcerpc_binding_handle_call(h,
29022 : NULL, &ndr_table_clusapi,
29023 : NDR_CLUSAPI_CREATENODEENUMEX, mem_ctx, r);
29024 :
29025 0 : return status;
29026 : }
29027 :
29028 : struct dcerpc_clusapi_CreateNodeEnumEx_state {
29029 : struct clusapi_CreateNodeEnumEx orig;
29030 : struct clusapi_CreateNodeEnumEx tmp;
29031 : TALLOC_CTX *out_mem_ctx;
29032 : };
29033 :
29034 : static void dcerpc_clusapi_CreateNodeEnumEx_done(struct tevent_req *subreq);
29035 :
29036 0 : struct tevent_req *dcerpc_clusapi_CreateNodeEnumEx_send(TALLOC_CTX *mem_ctx,
29037 : struct tevent_context *ev,
29038 : struct dcerpc_binding_handle *h,
29039 : struct policy_handle _hNode /* [in] */,
29040 : uint32_t _dwType /* [in] */,
29041 : uint32_t _dwOptions /* [in] */,
29042 : struct ENUM_LIST **_ReturnIdEnum /* [out] [ref] */,
29043 : struct ENUM_LIST **_ReturnNameEnum /* [out] [ref] */,
29044 : WERROR *_rpc_status /* [out] [ref] */)
29045 : {
29046 : struct tevent_req *req;
29047 : struct dcerpc_clusapi_CreateNodeEnumEx_state *state;
29048 : struct tevent_req *subreq;
29049 :
29050 0 : req = tevent_req_create(mem_ctx, &state,
29051 : struct dcerpc_clusapi_CreateNodeEnumEx_state);
29052 0 : if (req == NULL) {
29053 0 : return NULL;
29054 : }
29055 0 : state->out_mem_ctx = NULL;
29056 :
29057 : /* In parameters */
29058 0 : state->orig.in.hNode = _hNode;
29059 0 : state->orig.in.dwType = _dwType;
29060 0 : state->orig.in.dwOptions = _dwOptions;
29061 :
29062 : /* Out parameters */
29063 0 : state->orig.out.ReturnIdEnum = _ReturnIdEnum;
29064 0 : state->orig.out.ReturnNameEnum = _ReturnNameEnum;
29065 0 : state->orig.out.rpc_status = _rpc_status;
29066 :
29067 : /* Result */
29068 0 : NDR_ZERO_STRUCT(state->orig.out.result);
29069 :
29070 0 : state->out_mem_ctx = talloc_named_const(state, 0,
29071 : "dcerpc_clusapi_CreateNodeEnumEx_out_memory");
29072 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29073 0 : return tevent_req_post(req, ev);
29074 : }
29075 :
29076 : /* make a temporary copy, that we pass to the dispatch function */
29077 0 : state->tmp = state->orig;
29078 :
29079 0 : subreq = dcerpc_clusapi_CreateNodeEnumEx_r_send(state, ev, h, &state->tmp);
29080 0 : if (tevent_req_nomem(subreq, req)) {
29081 0 : return tevent_req_post(req, ev);
29082 : }
29083 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNodeEnumEx_done, req);
29084 0 : return req;
29085 : }
29086 :
29087 0 : static void dcerpc_clusapi_CreateNodeEnumEx_done(struct tevent_req *subreq)
29088 : {
29089 0 : struct tevent_req *req = tevent_req_callback_data(
29090 : subreq, struct tevent_req);
29091 0 : struct dcerpc_clusapi_CreateNodeEnumEx_state *state = tevent_req_data(
29092 : req, struct dcerpc_clusapi_CreateNodeEnumEx_state);
29093 : NTSTATUS status;
29094 : TALLOC_CTX *mem_ctx;
29095 :
29096 0 : if (state->out_mem_ctx) {
29097 0 : mem_ctx = state->out_mem_ctx;
29098 : } else {
29099 0 : mem_ctx = state;
29100 : }
29101 :
29102 0 : status = dcerpc_clusapi_CreateNodeEnumEx_r_recv(subreq, mem_ctx);
29103 0 : TALLOC_FREE(subreq);
29104 0 : if (tevent_req_nterror(req, status)) {
29105 0 : return;
29106 : }
29107 :
29108 : /* Copy out parameters */
29109 0 : *state->orig.out.ReturnIdEnum = *state->tmp.out.ReturnIdEnum;
29110 0 : *state->orig.out.ReturnNameEnum = *state->tmp.out.ReturnNameEnum;
29111 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
29112 :
29113 : /* Copy result */
29114 0 : state->orig.out.result = state->tmp.out.result;
29115 :
29116 : /* Reset temporary structure */
29117 0 : NDR_ZERO_STRUCT(state->tmp);
29118 :
29119 0 : tevent_req_done(req);
29120 : }
29121 :
29122 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnumEx_recv(struct tevent_req *req,
29123 : TALLOC_CTX *mem_ctx,
29124 : WERROR *result)
29125 : {
29126 0 : struct dcerpc_clusapi_CreateNodeEnumEx_state *state = tevent_req_data(
29127 : req, struct dcerpc_clusapi_CreateNodeEnumEx_state);
29128 : NTSTATUS status;
29129 :
29130 0 : if (tevent_req_is_nterror(req, &status)) {
29131 0 : tevent_req_received(req);
29132 0 : return status;
29133 : }
29134 :
29135 : /* Steal possible out parameters to the callers context */
29136 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29137 :
29138 : /* Return result */
29139 0 : *result = state->orig.out.result;
29140 :
29141 0 : tevent_req_received(req);
29142 0 : return NT_STATUS_OK;
29143 : }
29144 :
29145 0 : NTSTATUS dcerpc_clusapi_CreateNodeEnumEx(struct dcerpc_binding_handle *h,
29146 : TALLOC_CTX *mem_ctx,
29147 : struct policy_handle _hNode /* [in] */,
29148 : uint32_t _dwType /* [in] */,
29149 : uint32_t _dwOptions /* [in] */,
29150 : struct ENUM_LIST **_ReturnIdEnum /* [out] [ref] */,
29151 : struct ENUM_LIST **_ReturnNameEnum /* [out] [ref] */,
29152 : WERROR *_rpc_status /* [out] [ref] */,
29153 : WERROR *result)
29154 : {
29155 : struct clusapi_CreateNodeEnumEx r;
29156 : NTSTATUS status;
29157 :
29158 : /* In parameters */
29159 0 : r.in.hNode = _hNode;
29160 0 : r.in.dwType = _dwType;
29161 0 : r.in.dwOptions = _dwOptions;
29162 :
29163 : /* Out parameters */
29164 0 : r.out.ReturnIdEnum = _ReturnIdEnum;
29165 0 : r.out.ReturnNameEnum = _ReturnNameEnum;
29166 0 : r.out.rpc_status = _rpc_status;
29167 :
29168 : /* Result */
29169 0 : NDR_ZERO_STRUCT(r.out.result);
29170 :
29171 0 : status = dcerpc_clusapi_CreateNodeEnumEx_r(h, mem_ctx, &r);
29172 0 : if (!NT_STATUS_IS_OK(status)) {
29173 0 : return status;
29174 : }
29175 :
29176 : /* Return variables */
29177 0 : *_ReturnIdEnum = *r.out.ReturnIdEnum;
29178 0 : *_ReturnNameEnum = *r.out.ReturnNameEnum;
29179 0 : *_rpc_status = *r.out.rpc_status;
29180 :
29181 : /* Return result */
29182 0 : *result = r.out.result;
29183 :
29184 0 : return NT_STATUS_OK;
29185 : }
29186 :
29187 : struct dcerpc_clusapi_CreateEnumEx_r_state {
29188 : TALLOC_CTX *out_mem_ctx;
29189 : };
29190 :
29191 : static void dcerpc_clusapi_CreateEnumEx_r_done(struct tevent_req *subreq);
29192 :
29193 0 : struct tevent_req *dcerpc_clusapi_CreateEnumEx_r_send(TALLOC_CTX *mem_ctx,
29194 : struct tevent_context *ev,
29195 : struct dcerpc_binding_handle *h,
29196 : struct clusapi_CreateEnumEx *r)
29197 : {
29198 : struct tevent_req *req;
29199 : struct dcerpc_clusapi_CreateEnumEx_r_state *state;
29200 : struct tevent_req *subreq;
29201 :
29202 0 : req = tevent_req_create(mem_ctx, &state,
29203 : struct dcerpc_clusapi_CreateEnumEx_r_state);
29204 0 : if (req == NULL) {
29205 0 : return NULL;
29206 : }
29207 :
29208 0 : state->out_mem_ctx = talloc_new(state);
29209 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29210 0 : return tevent_req_post(req, ev);
29211 : }
29212 :
29213 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
29214 : NULL, &ndr_table_clusapi,
29215 0 : NDR_CLUSAPI_CREATEENUMEX, state->out_mem_ctx, r);
29216 0 : if (tevent_req_nomem(subreq, req)) {
29217 0 : return tevent_req_post(req, ev);
29218 : }
29219 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateEnumEx_r_done, req);
29220 :
29221 0 : return req;
29222 : }
29223 :
29224 0 : static void dcerpc_clusapi_CreateEnumEx_r_done(struct tevent_req *subreq)
29225 : {
29226 0 : struct tevent_req *req =
29227 0 : tevent_req_callback_data(subreq,
29228 : struct tevent_req);
29229 : NTSTATUS status;
29230 :
29231 0 : status = dcerpc_binding_handle_call_recv(subreq);
29232 0 : TALLOC_FREE(subreq);
29233 0 : if (tevent_req_nterror(req, status)) {
29234 0 : return;
29235 : }
29236 :
29237 0 : tevent_req_done(req);
29238 : }
29239 :
29240 0 : NTSTATUS dcerpc_clusapi_CreateEnumEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
29241 : {
29242 0 : struct dcerpc_clusapi_CreateEnumEx_r_state *state =
29243 0 : tevent_req_data(req,
29244 : struct dcerpc_clusapi_CreateEnumEx_r_state);
29245 : NTSTATUS status;
29246 :
29247 0 : if (tevent_req_is_nterror(req, &status)) {
29248 0 : tevent_req_received(req);
29249 0 : return status;
29250 : }
29251 :
29252 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29253 :
29254 0 : tevent_req_received(req);
29255 0 : return NT_STATUS_OK;
29256 : }
29257 :
29258 0 : NTSTATUS dcerpc_clusapi_CreateEnumEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateEnumEx *r)
29259 : {
29260 : NTSTATUS status;
29261 :
29262 0 : status = dcerpc_binding_handle_call(h,
29263 : NULL, &ndr_table_clusapi,
29264 : NDR_CLUSAPI_CREATEENUMEX, mem_ctx, r);
29265 :
29266 0 : return status;
29267 : }
29268 :
29269 : struct dcerpc_clusapi_CreateEnumEx_state {
29270 : struct clusapi_CreateEnumEx orig;
29271 : struct clusapi_CreateEnumEx tmp;
29272 : TALLOC_CTX *out_mem_ctx;
29273 : };
29274 :
29275 : static void dcerpc_clusapi_CreateEnumEx_done(struct tevent_req *subreq);
29276 :
29277 0 : struct tevent_req *dcerpc_clusapi_CreateEnumEx_send(TALLOC_CTX *mem_ctx,
29278 : struct tevent_context *ev,
29279 : struct dcerpc_binding_handle *h,
29280 : struct policy_handle _hCluster /* [in] */,
29281 : uint32_t _dwType /* [in] */,
29282 : uint32_t _dwOptions /* [in] */,
29283 : struct ENUM_LIST **_ReturnIdEnum /* [out] [ref] */,
29284 : struct ENUM_LIST **_ReturnNameEnum /* [out] [ref] */,
29285 : WERROR *_rpc_status /* [out] [ref] */)
29286 : {
29287 : struct tevent_req *req;
29288 : struct dcerpc_clusapi_CreateEnumEx_state *state;
29289 : struct tevent_req *subreq;
29290 :
29291 0 : req = tevent_req_create(mem_ctx, &state,
29292 : struct dcerpc_clusapi_CreateEnumEx_state);
29293 0 : if (req == NULL) {
29294 0 : return NULL;
29295 : }
29296 0 : state->out_mem_ctx = NULL;
29297 :
29298 : /* In parameters */
29299 0 : state->orig.in.hCluster = _hCluster;
29300 0 : state->orig.in.dwType = _dwType;
29301 0 : state->orig.in.dwOptions = _dwOptions;
29302 :
29303 : /* Out parameters */
29304 0 : state->orig.out.ReturnIdEnum = _ReturnIdEnum;
29305 0 : state->orig.out.ReturnNameEnum = _ReturnNameEnum;
29306 0 : state->orig.out.rpc_status = _rpc_status;
29307 :
29308 : /* Result */
29309 0 : NDR_ZERO_STRUCT(state->orig.out.result);
29310 :
29311 0 : state->out_mem_ctx = talloc_named_const(state, 0,
29312 : "dcerpc_clusapi_CreateEnumEx_out_memory");
29313 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29314 0 : return tevent_req_post(req, ev);
29315 : }
29316 :
29317 : /* make a temporary copy, that we pass to the dispatch function */
29318 0 : state->tmp = state->orig;
29319 :
29320 0 : subreq = dcerpc_clusapi_CreateEnumEx_r_send(state, ev, h, &state->tmp);
29321 0 : if (tevent_req_nomem(subreq, req)) {
29322 0 : return tevent_req_post(req, ev);
29323 : }
29324 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateEnumEx_done, req);
29325 0 : return req;
29326 : }
29327 :
29328 0 : static void dcerpc_clusapi_CreateEnumEx_done(struct tevent_req *subreq)
29329 : {
29330 0 : struct tevent_req *req = tevent_req_callback_data(
29331 : subreq, struct tevent_req);
29332 0 : struct dcerpc_clusapi_CreateEnumEx_state *state = tevent_req_data(
29333 : req, struct dcerpc_clusapi_CreateEnumEx_state);
29334 : NTSTATUS status;
29335 : TALLOC_CTX *mem_ctx;
29336 :
29337 0 : if (state->out_mem_ctx) {
29338 0 : mem_ctx = state->out_mem_ctx;
29339 : } else {
29340 0 : mem_ctx = state;
29341 : }
29342 :
29343 0 : status = dcerpc_clusapi_CreateEnumEx_r_recv(subreq, mem_ctx);
29344 0 : TALLOC_FREE(subreq);
29345 0 : if (tevent_req_nterror(req, status)) {
29346 0 : return;
29347 : }
29348 :
29349 : /* Copy out parameters */
29350 0 : *state->orig.out.ReturnIdEnum = *state->tmp.out.ReturnIdEnum;
29351 0 : *state->orig.out.ReturnNameEnum = *state->tmp.out.ReturnNameEnum;
29352 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
29353 :
29354 : /* Copy result */
29355 0 : state->orig.out.result = state->tmp.out.result;
29356 :
29357 : /* Reset temporary structure */
29358 0 : NDR_ZERO_STRUCT(state->tmp);
29359 :
29360 0 : tevent_req_done(req);
29361 : }
29362 :
29363 0 : NTSTATUS dcerpc_clusapi_CreateEnumEx_recv(struct tevent_req *req,
29364 : TALLOC_CTX *mem_ctx,
29365 : WERROR *result)
29366 : {
29367 0 : struct dcerpc_clusapi_CreateEnumEx_state *state = tevent_req_data(
29368 : req, struct dcerpc_clusapi_CreateEnumEx_state);
29369 : NTSTATUS status;
29370 :
29371 0 : if (tevent_req_is_nterror(req, &status)) {
29372 0 : tevent_req_received(req);
29373 0 : return status;
29374 : }
29375 :
29376 : /* Steal possible out parameters to the callers context */
29377 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29378 :
29379 : /* Return result */
29380 0 : *result = state->orig.out.result;
29381 :
29382 0 : tevent_req_received(req);
29383 0 : return NT_STATUS_OK;
29384 : }
29385 :
29386 0 : NTSTATUS dcerpc_clusapi_CreateEnumEx(struct dcerpc_binding_handle *h,
29387 : TALLOC_CTX *mem_ctx,
29388 : struct policy_handle _hCluster /* [in] */,
29389 : uint32_t _dwType /* [in] */,
29390 : uint32_t _dwOptions /* [in] */,
29391 : struct ENUM_LIST **_ReturnIdEnum /* [out] [ref] */,
29392 : struct ENUM_LIST **_ReturnNameEnum /* [out] [ref] */,
29393 : WERROR *_rpc_status /* [out] [ref] */,
29394 : WERROR *result)
29395 : {
29396 : struct clusapi_CreateEnumEx r;
29397 : NTSTATUS status;
29398 :
29399 : /* In parameters */
29400 0 : r.in.hCluster = _hCluster;
29401 0 : r.in.dwType = _dwType;
29402 0 : r.in.dwOptions = _dwOptions;
29403 :
29404 : /* Out parameters */
29405 0 : r.out.ReturnIdEnum = _ReturnIdEnum;
29406 0 : r.out.ReturnNameEnum = _ReturnNameEnum;
29407 0 : r.out.rpc_status = _rpc_status;
29408 :
29409 : /* Result */
29410 0 : NDR_ZERO_STRUCT(r.out.result);
29411 :
29412 0 : status = dcerpc_clusapi_CreateEnumEx_r(h, mem_ctx, &r);
29413 0 : if (!NT_STATUS_IS_OK(status)) {
29414 0 : return status;
29415 : }
29416 :
29417 : /* Return variables */
29418 0 : *_ReturnIdEnum = *r.out.ReturnIdEnum;
29419 0 : *_ReturnNameEnum = *r.out.ReturnNameEnum;
29420 0 : *_rpc_status = *r.out.rpc_status;
29421 :
29422 : /* Return result */
29423 0 : *result = r.out.result;
29424 :
29425 0 : return NT_STATUS_OK;
29426 : }
29427 :
29428 : struct dcerpc_clusapi_PauseNodeEx_r_state {
29429 : TALLOC_CTX *out_mem_ctx;
29430 : };
29431 :
29432 : static void dcerpc_clusapi_PauseNodeEx_r_done(struct tevent_req *subreq);
29433 :
29434 0 : struct tevent_req *dcerpc_clusapi_PauseNodeEx_r_send(TALLOC_CTX *mem_ctx,
29435 : struct tevent_context *ev,
29436 : struct dcerpc_binding_handle *h,
29437 : struct clusapi_PauseNodeEx *r)
29438 : {
29439 : struct tevent_req *req;
29440 : struct dcerpc_clusapi_PauseNodeEx_r_state *state;
29441 : struct tevent_req *subreq;
29442 :
29443 0 : req = tevent_req_create(mem_ctx, &state,
29444 : struct dcerpc_clusapi_PauseNodeEx_r_state);
29445 0 : if (req == NULL) {
29446 0 : return NULL;
29447 : }
29448 :
29449 0 : state->out_mem_ctx = talloc_new(state);
29450 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29451 0 : return tevent_req_post(req, ev);
29452 : }
29453 :
29454 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
29455 : NULL, &ndr_table_clusapi,
29456 0 : NDR_CLUSAPI_PAUSENODEEX, state->out_mem_ctx, r);
29457 0 : if (tevent_req_nomem(subreq, req)) {
29458 0 : return tevent_req_post(req, ev);
29459 : }
29460 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNodeEx_r_done, req);
29461 :
29462 0 : return req;
29463 : }
29464 :
29465 0 : static void dcerpc_clusapi_PauseNodeEx_r_done(struct tevent_req *subreq)
29466 : {
29467 0 : struct tevent_req *req =
29468 0 : tevent_req_callback_data(subreq,
29469 : struct tevent_req);
29470 : NTSTATUS status;
29471 :
29472 0 : status = dcerpc_binding_handle_call_recv(subreq);
29473 0 : TALLOC_FREE(subreq);
29474 0 : if (tevent_req_nterror(req, status)) {
29475 0 : return;
29476 : }
29477 :
29478 0 : tevent_req_done(req);
29479 : }
29480 :
29481 0 : NTSTATUS dcerpc_clusapi_PauseNodeEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
29482 : {
29483 0 : struct dcerpc_clusapi_PauseNodeEx_r_state *state =
29484 0 : tevent_req_data(req,
29485 : struct dcerpc_clusapi_PauseNodeEx_r_state);
29486 : NTSTATUS status;
29487 :
29488 0 : if (tevent_req_is_nterror(req, &status)) {
29489 0 : tevent_req_received(req);
29490 0 : return status;
29491 : }
29492 :
29493 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29494 :
29495 0 : tevent_req_received(req);
29496 0 : return NT_STATUS_OK;
29497 : }
29498 :
29499 0 : NTSTATUS dcerpc_clusapi_PauseNodeEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_PauseNodeEx *r)
29500 : {
29501 : NTSTATUS status;
29502 :
29503 0 : status = dcerpc_binding_handle_call(h,
29504 : NULL, &ndr_table_clusapi,
29505 : NDR_CLUSAPI_PAUSENODEEX, mem_ctx, r);
29506 :
29507 0 : return status;
29508 : }
29509 :
29510 : struct dcerpc_clusapi_PauseNodeEx_state {
29511 : struct clusapi_PauseNodeEx orig;
29512 : struct clusapi_PauseNodeEx tmp;
29513 : TALLOC_CTX *out_mem_ctx;
29514 : };
29515 :
29516 : static void dcerpc_clusapi_PauseNodeEx_done(struct tevent_req *subreq);
29517 :
29518 0 : struct tevent_req *dcerpc_clusapi_PauseNodeEx_send(TALLOC_CTX *mem_ctx,
29519 : struct tevent_context *ev,
29520 : struct dcerpc_binding_handle *h,
29521 : struct policy_handle _hNode /* [in] */,
29522 : uint8_t _bDrainNode /* [in] */,
29523 : uint32_t _dwPauseFlags /* [in] */,
29524 : WERROR *_rpc_status /* [out] [ref] */)
29525 : {
29526 : struct tevent_req *req;
29527 : struct dcerpc_clusapi_PauseNodeEx_state *state;
29528 : struct tevent_req *subreq;
29529 :
29530 0 : req = tevent_req_create(mem_ctx, &state,
29531 : struct dcerpc_clusapi_PauseNodeEx_state);
29532 0 : if (req == NULL) {
29533 0 : return NULL;
29534 : }
29535 0 : state->out_mem_ctx = NULL;
29536 :
29537 : /* In parameters */
29538 0 : state->orig.in.hNode = _hNode;
29539 0 : state->orig.in.bDrainNode = _bDrainNode;
29540 0 : state->orig.in.dwPauseFlags = _dwPauseFlags;
29541 :
29542 : /* Out parameters */
29543 0 : state->orig.out.rpc_status = _rpc_status;
29544 :
29545 : /* Result */
29546 0 : NDR_ZERO_STRUCT(state->orig.out.result);
29547 :
29548 0 : state->out_mem_ctx = talloc_named_const(state, 0,
29549 : "dcerpc_clusapi_PauseNodeEx_out_memory");
29550 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29551 0 : return tevent_req_post(req, ev);
29552 : }
29553 :
29554 : /* make a temporary copy, that we pass to the dispatch function */
29555 0 : state->tmp = state->orig;
29556 :
29557 0 : subreq = dcerpc_clusapi_PauseNodeEx_r_send(state, ev, h, &state->tmp);
29558 0 : if (tevent_req_nomem(subreq, req)) {
29559 0 : return tevent_req_post(req, ev);
29560 : }
29561 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNodeEx_done, req);
29562 0 : return req;
29563 : }
29564 :
29565 0 : static void dcerpc_clusapi_PauseNodeEx_done(struct tevent_req *subreq)
29566 : {
29567 0 : struct tevent_req *req = tevent_req_callback_data(
29568 : subreq, struct tevent_req);
29569 0 : struct dcerpc_clusapi_PauseNodeEx_state *state = tevent_req_data(
29570 : req, struct dcerpc_clusapi_PauseNodeEx_state);
29571 : NTSTATUS status;
29572 : TALLOC_CTX *mem_ctx;
29573 :
29574 0 : if (state->out_mem_ctx) {
29575 0 : mem_ctx = state->out_mem_ctx;
29576 : } else {
29577 0 : mem_ctx = state;
29578 : }
29579 :
29580 0 : status = dcerpc_clusapi_PauseNodeEx_r_recv(subreq, mem_ctx);
29581 0 : TALLOC_FREE(subreq);
29582 0 : if (tevent_req_nterror(req, status)) {
29583 0 : return;
29584 : }
29585 :
29586 : /* Copy out parameters */
29587 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
29588 :
29589 : /* Copy result */
29590 0 : state->orig.out.result = state->tmp.out.result;
29591 :
29592 : /* Reset temporary structure */
29593 0 : NDR_ZERO_STRUCT(state->tmp);
29594 :
29595 0 : tevent_req_done(req);
29596 : }
29597 :
29598 0 : NTSTATUS dcerpc_clusapi_PauseNodeEx_recv(struct tevent_req *req,
29599 : TALLOC_CTX *mem_ctx,
29600 : WERROR *result)
29601 : {
29602 0 : struct dcerpc_clusapi_PauseNodeEx_state *state = tevent_req_data(
29603 : req, struct dcerpc_clusapi_PauseNodeEx_state);
29604 : NTSTATUS status;
29605 :
29606 0 : if (tevent_req_is_nterror(req, &status)) {
29607 0 : tevent_req_received(req);
29608 0 : return status;
29609 : }
29610 :
29611 : /* Steal possible out parameters to the callers context */
29612 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29613 :
29614 : /* Return result */
29615 0 : *result = state->orig.out.result;
29616 :
29617 0 : tevent_req_received(req);
29618 0 : return NT_STATUS_OK;
29619 : }
29620 :
29621 0 : NTSTATUS dcerpc_clusapi_PauseNodeEx(struct dcerpc_binding_handle *h,
29622 : TALLOC_CTX *mem_ctx,
29623 : struct policy_handle _hNode /* [in] */,
29624 : uint8_t _bDrainNode /* [in] */,
29625 : uint32_t _dwPauseFlags /* [in] */,
29626 : WERROR *_rpc_status /* [out] [ref] */,
29627 : WERROR *result)
29628 : {
29629 : struct clusapi_PauseNodeEx r;
29630 : NTSTATUS status;
29631 :
29632 : /* In parameters */
29633 0 : r.in.hNode = _hNode;
29634 0 : r.in.bDrainNode = _bDrainNode;
29635 0 : r.in.dwPauseFlags = _dwPauseFlags;
29636 :
29637 : /* Out parameters */
29638 0 : r.out.rpc_status = _rpc_status;
29639 :
29640 : /* Result */
29641 0 : NDR_ZERO_STRUCT(r.out.result);
29642 :
29643 0 : status = dcerpc_clusapi_PauseNodeEx_r(h, mem_ctx, &r);
29644 0 : if (!NT_STATUS_IS_OK(status)) {
29645 0 : return status;
29646 : }
29647 :
29648 : /* Return variables */
29649 0 : *_rpc_status = *r.out.rpc_status;
29650 :
29651 : /* Return result */
29652 0 : *result = r.out.result;
29653 :
29654 0 : return NT_STATUS_OK;
29655 : }
29656 :
29657 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_r_state {
29658 : TALLOC_CTX *out_mem_ctx;
29659 : };
29660 :
29661 : static void dcerpc_clusapi_PauseNodeWithDrainTarget_r_done(struct tevent_req *subreq);
29662 :
29663 0 : struct tevent_req *dcerpc_clusapi_PauseNodeWithDrainTarget_r_send(TALLOC_CTX *mem_ctx,
29664 : struct tevent_context *ev,
29665 : struct dcerpc_binding_handle *h,
29666 : struct clusapi_PauseNodeWithDrainTarget *r)
29667 : {
29668 : struct tevent_req *req;
29669 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_r_state *state;
29670 : struct tevent_req *subreq;
29671 :
29672 0 : req = tevent_req_create(mem_ctx, &state,
29673 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_r_state);
29674 0 : if (req == NULL) {
29675 0 : return NULL;
29676 : }
29677 :
29678 0 : state->out_mem_ctx = talloc_new(state);
29679 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29680 0 : return tevent_req_post(req, ev);
29681 : }
29682 :
29683 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
29684 : NULL, &ndr_table_clusapi,
29685 0 : NDR_CLUSAPI_PAUSENODEWITHDRAINTARGET, state->out_mem_ctx, r);
29686 0 : if (tevent_req_nomem(subreq, req)) {
29687 0 : return tevent_req_post(req, ev);
29688 : }
29689 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNodeWithDrainTarget_r_done, req);
29690 :
29691 0 : return req;
29692 : }
29693 :
29694 0 : static void dcerpc_clusapi_PauseNodeWithDrainTarget_r_done(struct tevent_req *subreq)
29695 : {
29696 0 : struct tevent_req *req =
29697 0 : tevent_req_callback_data(subreq,
29698 : struct tevent_req);
29699 : NTSTATUS status;
29700 :
29701 0 : status = dcerpc_binding_handle_call_recv(subreq);
29702 0 : TALLOC_FREE(subreq);
29703 0 : if (tevent_req_nterror(req, status)) {
29704 0 : return;
29705 : }
29706 :
29707 0 : tevent_req_done(req);
29708 : }
29709 :
29710 0 : NTSTATUS dcerpc_clusapi_PauseNodeWithDrainTarget_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
29711 : {
29712 0 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_r_state *state =
29713 0 : tevent_req_data(req,
29714 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_r_state);
29715 : NTSTATUS status;
29716 :
29717 0 : if (tevent_req_is_nterror(req, &status)) {
29718 0 : tevent_req_received(req);
29719 0 : return status;
29720 : }
29721 :
29722 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29723 :
29724 0 : tevent_req_received(req);
29725 0 : return NT_STATUS_OK;
29726 : }
29727 :
29728 0 : NTSTATUS dcerpc_clusapi_PauseNodeWithDrainTarget_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_PauseNodeWithDrainTarget *r)
29729 : {
29730 : NTSTATUS status;
29731 :
29732 0 : status = dcerpc_binding_handle_call(h,
29733 : NULL, &ndr_table_clusapi,
29734 : NDR_CLUSAPI_PAUSENODEWITHDRAINTARGET, mem_ctx, r);
29735 :
29736 0 : return status;
29737 : }
29738 :
29739 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_state {
29740 : struct clusapi_PauseNodeWithDrainTarget orig;
29741 : struct clusapi_PauseNodeWithDrainTarget tmp;
29742 : TALLOC_CTX *out_mem_ctx;
29743 : };
29744 :
29745 : static void dcerpc_clusapi_PauseNodeWithDrainTarget_done(struct tevent_req *subreq);
29746 :
29747 0 : struct tevent_req *dcerpc_clusapi_PauseNodeWithDrainTarget_send(TALLOC_CTX *mem_ctx,
29748 : struct tevent_context *ev,
29749 : struct dcerpc_binding_handle *h,
29750 : struct policy_handle _hNode /* [in] */,
29751 : uint32_t _dwPauseFlags /* [in] */,
29752 : struct policy_handle _hNodeDrainTarget /* [in] */,
29753 : WERROR *_rpc_status /* [out] [ref] */)
29754 : {
29755 : struct tevent_req *req;
29756 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_state *state;
29757 : struct tevent_req *subreq;
29758 :
29759 0 : req = tevent_req_create(mem_ctx, &state,
29760 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_state);
29761 0 : if (req == NULL) {
29762 0 : return NULL;
29763 : }
29764 0 : state->out_mem_ctx = NULL;
29765 :
29766 : /* In parameters */
29767 0 : state->orig.in.hNode = _hNode;
29768 0 : state->orig.in.dwPauseFlags = _dwPauseFlags;
29769 0 : state->orig.in.hNodeDrainTarget = _hNodeDrainTarget;
29770 :
29771 : /* Out parameters */
29772 0 : state->orig.out.rpc_status = _rpc_status;
29773 :
29774 : /* Result */
29775 0 : NDR_ZERO_STRUCT(state->orig.out.result);
29776 :
29777 0 : state->out_mem_ctx = talloc_named_const(state, 0,
29778 : "dcerpc_clusapi_PauseNodeWithDrainTarget_out_memory");
29779 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29780 0 : return tevent_req_post(req, ev);
29781 : }
29782 :
29783 : /* make a temporary copy, that we pass to the dispatch function */
29784 0 : state->tmp = state->orig;
29785 :
29786 0 : subreq = dcerpc_clusapi_PauseNodeWithDrainTarget_r_send(state, ev, h, &state->tmp);
29787 0 : if (tevent_req_nomem(subreq, req)) {
29788 0 : return tevent_req_post(req, ev);
29789 : }
29790 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_PauseNodeWithDrainTarget_done, req);
29791 0 : return req;
29792 : }
29793 :
29794 0 : static void dcerpc_clusapi_PauseNodeWithDrainTarget_done(struct tevent_req *subreq)
29795 : {
29796 0 : struct tevent_req *req = tevent_req_callback_data(
29797 : subreq, struct tevent_req);
29798 0 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_state *state = tevent_req_data(
29799 : req, struct dcerpc_clusapi_PauseNodeWithDrainTarget_state);
29800 : NTSTATUS status;
29801 : TALLOC_CTX *mem_ctx;
29802 :
29803 0 : if (state->out_mem_ctx) {
29804 0 : mem_ctx = state->out_mem_ctx;
29805 : } else {
29806 0 : mem_ctx = state;
29807 : }
29808 :
29809 0 : status = dcerpc_clusapi_PauseNodeWithDrainTarget_r_recv(subreq, mem_ctx);
29810 0 : TALLOC_FREE(subreq);
29811 0 : if (tevent_req_nterror(req, status)) {
29812 0 : return;
29813 : }
29814 :
29815 : /* Copy out parameters */
29816 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
29817 :
29818 : /* Copy result */
29819 0 : state->orig.out.result = state->tmp.out.result;
29820 :
29821 : /* Reset temporary structure */
29822 0 : NDR_ZERO_STRUCT(state->tmp);
29823 :
29824 0 : tevent_req_done(req);
29825 : }
29826 :
29827 0 : NTSTATUS dcerpc_clusapi_PauseNodeWithDrainTarget_recv(struct tevent_req *req,
29828 : TALLOC_CTX *mem_ctx,
29829 : WERROR *result)
29830 : {
29831 0 : struct dcerpc_clusapi_PauseNodeWithDrainTarget_state *state = tevent_req_data(
29832 : req, struct dcerpc_clusapi_PauseNodeWithDrainTarget_state);
29833 : NTSTATUS status;
29834 :
29835 0 : if (tevent_req_is_nterror(req, &status)) {
29836 0 : tevent_req_received(req);
29837 0 : return status;
29838 : }
29839 :
29840 : /* Steal possible out parameters to the callers context */
29841 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29842 :
29843 : /* Return result */
29844 0 : *result = state->orig.out.result;
29845 :
29846 0 : tevent_req_received(req);
29847 0 : return NT_STATUS_OK;
29848 : }
29849 :
29850 0 : NTSTATUS dcerpc_clusapi_PauseNodeWithDrainTarget(struct dcerpc_binding_handle *h,
29851 : TALLOC_CTX *mem_ctx,
29852 : struct policy_handle _hNode /* [in] */,
29853 : uint32_t _dwPauseFlags /* [in] */,
29854 : struct policy_handle _hNodeDrainTarget /* [in] */,
29855 : WERROR *_rpc_status /* [out] [ref] */,
29856 : WERROR *result)
29857 : {
29858 : struct clusapi_PauseNodeWithDrainTarget r;
29859 : NTSTATUS status;
29860 :
29861 : /* In parameters */
29862 0 : r.in.hNode = _hNode;
29863 0 : r.in.dwPauseFlags = _dwPauseFlags;
29864 0 : r.in.hNodeDrainTarget = _hNodeDrainTarget;
29865 :
29866 : /* Out parameters */
29867 0 : r.out.rpc_status = _rpc_status;
29868 :
29869 : /* Result */
29870 0 : NDR_ZERO_STRUCT(r.out.result);
29871 :
29872 0 : status = dcerpc_clusapi_PauseNodeWithDrainTarget_r(h, mem_ctx, &r);
29873 0 : if (!NT_STATUS_IS_OK(status)) {
29874 0 : return status;
29875 : }
29876 :
29877 : /* Return variables */
29878 0 : *_rpc_status = *r.out.rpc_status;
29879 :
29880 : /* Return result */
29881 0 : *result = r.out.result;
29882 :
29883 0 : return NT_STATUS_OK;
29884 : }
29885 :
29886 : struct dcerpc_clusapi_ResumeNodeEx_r_state {
29887 : TALLOC_CTX *out_mem_ctx;
29888 : };
29889 :
29890 : static void dcerpc_clusapi_ResumeNodeEx_r_done(struct tevent_req *subreq);
29891 :
29892 0 : struct tevent_req *dcerpc_clusapi_ResumeNodeEx_r_send(TALLOC_CTX *mem_ctx,
29893 : struct tevent_context *ev,
29894 : struct dcerpc_binding_handle *h,
29895 : struct clusapi_ResumeNodeEx *r)
29896 : {
29897 : struct tevent_req *req;
29898 : struct dcerpc_clusapi_ResumeNodeEx_r_state *state;
29899 : struct tevent_req *subreq;
29900 :
29901 0 : req = tevent_req_create(mem_ctx, &state,
29902 : struct dcerpc_clusapi_ResumeNodeEx_r_state);
29903 0 : if (req == NULL) {
29904 0 : return NULL;
29905 : }
29906 :
29907 0 : state->out_mem_ctx = talloc_new(state);
29908 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
29909 0 : return tevent_req_post(req, ev);
29910 : }
29911 :
29912 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
29913 : NULL, &ndr_table_clusapi,
29914 0 : NDR_CLUSAPI_RESUMENODEEX, state->out_mem_ctx, r);
29915 0 : if (tevent_req_nomem(subreq, req)) {
29916 0 : return tevent_req_post(req, ev);
29917 : }
29918 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResumeNodeEx_r_done, req);
29919 :
29920 0 : return req;
29921 : }
29922 :
29923 0 : static void dcerpc_clusapi_ResumeNodeEx_r_done(struct tevent_req *subreq)
29924 : {
29925 0 : struct tevent_req *req =
29926 0 : tevent_req_callback_data(subreq,
29927 : struct tevent_req);
29928 : NTSTATUS status;
29929 :
29930 0 : status = dcerpc_binding_handle_call_recv(subreq);
29931 0 : TALLOC_FREE(subreq);
29932 0 : if (tevent_req_nterror(req, status)) {
29933 0 : return;
29934 : }
29935 :
29936 0 : tevent_req_done(req);
29937 : }
29938 :
29939 0 : NTSTATUS dcerpc_clusapi_ResumeNodeEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
29940 : {
29941 0 : struct dcerpc_clusapi_ResumeNodeEx_r_state *state =
29942 0 : tevent_req_data(req,
29943 : struct dcerpc_clusapi_ResumeNodeEx_r_state);
29944 : NTSTATUS status;
29945 :
29946 0 : if (tevent_req_is_nterror(req, &status)) {
29947 0 : tevent_req_received(req);
29948 0 : return status;
29949 : }
29950 :
29951 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
29952 :
29953 0 : tevent_req_received(req);
29954 0 : return NT_STATUS_OK;
29955 : }
29956 :
29957 0 : NTSTATUS dcerpc_clusapi_ResumeNodeEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ResumeNodeEx *r)
29958 : {
29959 : NTSTATUS status;
29960 :
29961 0 : status = dcerpc_binding_handle_call(h,
29962 : NULL, &ndr_table_clusapi,
29963 : NDR_CLUSAPI_RESUMENODEEX, mem_ctx, r);
29964 :
29965 0 : return status;
29966 : }
29967 :
29968 : struct dcerpc_clusapi_ResumeNodeEx_state {
29969 : struct clusapi_ResumeNodeEx orig;
29970 : struct clusapi_ResumeNodeEx tmp;
29971 : TALLOC_CTX *out_mem_ctx;
29972 : };
29973 :
29974 : static void dcerpc_clusapi_ResumeNodeEx_done(struct tevent_req *subreq);
29975 :
29976 0 : struct tevent_req *dcerpc_clusapi_ResumeNodeEx_send(TALLOC_CTX *mem_ctx,
29977 : struct tevent_context *ev,
29978 : struct dcerpc_binding_handle *h,
29979 : struct policy_handle _hNode /* [in] */,
29980 : uint32_t _dwResumeFailbackType /* [in] */,
29981 : uint32_t _dwResumeFlagsReserved /* [in] */,
29982 : WERROR *_rpc_status /* [out] [ref] */)
29983 : {
29984 : struct tevent_req *req;
29985 : struct dcerpc_clusapi_ResumeNodeEx_state *state;
29986 : struct tevent_req *subreq;
29987 :
29988 0 : req = tevent_req_create(mem_ctx, &state,
29989 : struct dcerpc_clusapi_ResumeNodeEx_state);
29990 0 : if (req == NULL) {
29991 0 : return NULL;
29992 : }
29993 0 : state->out_mem_ctx = NULL;
29994 :
29995 : /* In parameters */
29996 0 : state->orig.in.hNode = _hNode;
29997 0 : state->orig.in.dwResumeFailbackType = _dwResumeFailbackType;
29998 0 : state->orig.in.dwResumeFlagsReserved = _dwResumeFlagsReserved;
29999 :
30000 : /* Out parameters */
30001 0 : state->orig.out.rpc_status = _rpc_status;
30002 :
30003 : /* Result */
30004 0 : NDR_ZERO_STRUCT(state->orig.out.result);
30005 :
30006 0 : state->out_mem_ctx = talloc_named_const(state, 0,
30007 : "dcerpc_clusapi_ResumeNodeEx_out_memory");
30008 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30009 0 : return tevent_req_post(req, ev);
30010 : }
30011 :
30012 : /* make a temporary copy, that we pass to the dispatch function */
30013 0 : state->tmp = state->orig;
30014 :
30015 0 : subreq = dcerpc_clusapi_ResumeNodeEx_r_send(state, ev, h, &state->tmp);
30016 0 : if (tevent_req_nomem(subreq, req)) {
30017 0 : return tevent_req_post(req, ev);
30018 : }
30019 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ResumeNodeEx_done, req);
30020 0 : return req;
30021 : }
30022 :
30023 0 : static void dcerpc_clusapi_ResumeNodeEx_done(struct tevent_req *subreq)
30024 : {
30025 0 : struct tevent_req *req = tevent_req_callback_data(
30026 : subreq, struct tevent_req);
30027 0 : struct dcerpc_clusapi_ResumeNodeEx_state *state = tevent_req_data(
30028 : req, struct dcerpc_clusapi_ResumeNodeEx_state);
30029 : NTSTATUS status;
30030 : TALLOC_CTX *mem_ctx;
30031 :
30032 0 : if (state->out_mem_ctx) {
30033 0 : mem_ctx = state->out_mem_ctx;
30034 : } else {
30035 0 : mem_ctx = state;
30036 : }
30037 :
30038 0 : status = dcerpc_clusapi_ResumeNodeEx_r_recv(subreq, mem_ctx);
30039 0 : TALLOC_FREE(subreq);
30040 0 : if (tevent_req_nterror(req, status)) {
30041 0 : return;
30042 : }
30043 :
30044 : /* Copy out parameters */
30045 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
30046 :
30047 : /* Copy result */
30048 0 : state->orig.out.result = state->tmp.out.result;
30049 :
30050 : /* Reset temporary structure */
30051 0 : NDR_ZERO_STRUCT(state->tmp);
30052 :
30053 0 : tevent_req_done(req);
30054 : }
30055 :
30056 0 : NTSTATUS dcerpc_clusapi_ResumeNodeEx_recv(struct tevent_req *req,
30057 : TALLOC_CTX *mem_ctx,
30058 : WERROR *result)
30059 : {
30060 0 : struct dcerpc_clusapi_ResumeNodeEx_state *state = tevent_req_data(
30061 : req, struct dcerpc_clusapi_ResumeNodeEx_state);
30062 : NTSTATUS status;
30063 :
30064 0 : if (tevent_req_is_nterror(req, &status)) {
30065 0 : tevent_req_received(req);
30066 0 : return status;
30067 : }
30068 :
30069 : /* Steal possible out parameters to the callers context */
30070 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30071 :
30072 : /* Return result */
30073 0 : *result = state->orig.out.result;
30074 :
30075 0 : tevent_req_received(req);
30076 0 : return NT_STATUS_OK;
30077 : }
30078 :
30079 0 : NTSTATUS dcerpc_clusapi_ResumeNodeEx(struct dcerpc_binding_handle *h,
30080 : TALLOC_CTX *mem_ctx,
30081 : struct policy_handle _hNode /* [in] */,
30082 : uint32_t _dwResumeFailbackType /* [in] */,
30083 : uint32_t _dwResumeFlagsReserved /* [in] */,
30084 : WERROR *_rpc_status /* [out] [ref] */,
30085 : WERROR *result)
30086 : {
30087 : struct clusapi_ResumeNodeEx r;
30088 : NTSTATUS status;
30089 :
30090 : /* In parameters */
30091 0 : r.in.hNode = _hNode;
30092 0 : r.in.dwResumeFailbackType = _dwResumeFailbackType;
30093 0 : r.in.dwResumeFlagsReserved = _dwResumeFlagsReserved;
30094 :
30095 : /* Out parameters */
30096 0 : r.out.rpc_status = _rpc_status;
30097 :
30098 : /* Result */
30099 0 : NDR_ZERO_STRUCT(r.out.result);
30100 :
30101 0 : status = dcerpc_clusapi_ResumeNodeEx_r(h, mem_ctx, &r);
30102 0 : if (!NT_STATUS_IS_OK(status)) {
30103 0 : return status;
30104 : }
30105 :
30106 : /* Return variables */
30107 0 : *_rpc_status = *r.out.rpc_status;
30108 :
30109 : /* Return result */
30110 0 : *result = r.out.result;
30111 :
30112 0 : return NT_STATUS_OK;
30113 : }
30114 :
30115 : struct dcerpc_clusapi_CreateGroupEx_r_state {
30116 : TALLOC_CTX *out_mem_ctx;
30117 : };
30118 :
30119 : static void dcerpc_clusapi_CreateGroupEx_r_done(struct tevent_req *subreq);
30120 :
30121 0 : struct tevent_req *dcerpc_clusapi_CreateGroupEx_r_send(TALLOC_CTX *mem_ctx,
30122 : struct tevent_context *ev,
30123 : struct dcerpc_binding_handle *h,
30124 : struct clusapi_CreateGroupEx *r)
30125 : {
30126 : struct tevent_req *req;
30127 : struct dcerpc_clusapi_CreateGroupEx_r_state *state;
30128 : struct tevent_req *subreq;
30129 :
30130 0 : req = tevent_req_create(mem_ctx, &state,
30131 : struct dcerpc_clusapi_CreateGroupEx_r_state);
30132 0 : if (req == NULL) {
30133 0 : return NULL;
30134 : }
30135 :
30136 0 : state->out_mem_ctx = talloc_new(state);
30137 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30138 0 : return tevent_req_post(req, ev);
30139 : }
30140 :
30141 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
30142 : NULL, &ndr_table_clusapi,
30143 0 : NDR_CLUSAPI_CREATEGROUPEX, state->out_mem_ctx, r);
30144 0 : if (tevent_req_nomem(subreq, req)) {
30145 0 : return tevent_req_post(req, ev);
30146 : }
30147 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupEx_r_done, req);
30148 :
30149 0 : return req;
30150 : }
30151 :
30152 0 : static void dcerpc_clusapi_CreateGroupEx_r_done(struct tevent_req *subreq)
30153 : {
30154 0 : struct tevent_req *req =
30155 0 : tevent_req_callback_data(subreq,
30156 : struct tevent_req);
30157 : NTSTATUS status;
30158 :
30159 0 : status = dcerpc_binding_handle_call_recv(subreq);
30160 0 : TALLOC_FREE(subreq);
30161 0 : if (tevent_req_nterror(req, status)) {
30162 0 : return;
30163 : }
30164 :
30165 0 : tevent_req_done(req);
30166 : }
30167 :
30168 0 : NTSTATUS dcerpc_clusapi_CreateGroupEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
30169 : {
30170 0 : struct dcerpc_clusapi_CreateGroupEx_r_state *state =
30171 0 : tevent_req_data(req,
30172 : struct dcerpc_clusapi_CreateGroupEx_r_state);
30173 : NTSTATUS status;
30174 :
30175 0 : if (tevent_req_is_nterror(req, &status)) {
30176 0 : tevent_req_received(req);
30177 0 : return status;
30178 : }
30179 :
30180 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30181 :
30182 0 : tevent_req_received(req);
30183 0 : return NT_STATUS_OK;
30184 : }
30185 :
30186 0 : NTSTATUS dcerpc_clusapi_CreateGroupEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroupEx *r)
30187 : {
30188 : NTSTATUS status;
30189 :
30190 0 : status = dcerpc_binding_handle_call(h,
30191 : NULL, &ndr_table_clusapi,
30192 : NDR_CLUSAPI_CREATEGROUPEX, mem_ctx, r);
30193 :
30194 0 : return status;
30195 : }
30196 :
30197 : struct dcerpc_clusapi_CreateGroupEx_state {
30198 : struct clusapi_CreateGroupEx orig;
30199 : struct clusapi_CreateGroupEx tmp;
30200 : TALLOC_CTX *out_mem_ctx;
30201 : };
30202 :
30203 : static void dcerpc_clusapi_CreateGroupEx_done(struct tevent_req *subreq);
30204 :
30205 0 : struct tevent_req *dcerpc_clusapi_CreateGroupEx_send(TALLOC_CTX *mem_ctx,
30206 : struct tevent_context *ev,
30207 : struct dcerpc_binding_handle *h,
30208 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
30209 : struct CLUSTER_CREATE_GROUP_INFO_RPC *_pGroupInfo /* [in] [unique] */,
30210 : WERROR *_Status /* [out] [ref] */,
30211 : WERROR *_rpc_status /* [out] [ref] */,
30212 : struct policy_handle *_hGroup /* [out] [ref] */)
30213 : {
30214 : struct tevent_req *req;
30215 : struct dcerpc_clusapi_CreateGroupEx_state *state;
30216 : struct tevent_req *subreq;
30217 :
30218 0 : req = tevent_req_create(mem_ctx, &state,
30219 : struct dcerpc_clusapi_CreateGroupEx_state);
30220 0 : if (req == NULL) {
30221 0 : return NULL;
30222 : }
30223 0 : state->out_mem_ctx = NULL;
30224 :
30225 : /* In parameters */
30226 0 : state->orig.in.lpszGroupName = _lpszGroupName;
30227 0 : state->orig.in.pGroupInfo = _pGroupInfo;
30228 :
30229 : /* Out parameters */
30230 0 : state->orig.out.Status = _Status;
30231 0 : state->orig.out.rpc_status = _rpc_status;
30232 0 : state->orig.out.hGroup = _hGroup;
30233 :
30234 0 : state->out_mem_ctx = talloc_named_const(state, 0,
30235 : "dcerpc_clusapi_CreateGroupEx_out_memory");
30236 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30237 0 : return tevent_req_post(req, ev);
30238 : }
30239 :
30240 : /* make a temporary copy, that we pass to the dispatch function */
30241 0 : state->tmp = state->orig;
30242 :
30243 0 : subreq = dcerpc_clusapi_CreateGroupEx_r_send(state, ev, h, &state->tmp);
30244 0 : if (tevent_req_nomem(subreq, req)) {
30245 0 : return tevent_req_post(req, ev);
30246 : }
30247 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupEx_done, req);
30248 0 : return req;
30249 : }
30250 :
30251 0 : static void dcerpc_clusapi_CreateGroupEx_done(struct tevent_req *subreq)
30252 : {
30253 0 : struct tevent_req *req = tevent_req_callback_data(
30254 : subreq, struct tevent_req);
30255 0 : struct dcerpc_clusapi_CreateGroupEx_state *state = tevent_req_data(
30256 : req, struct dcerpc_clusapi_CreateGroupEx_state);
30257 : NTSTATUS status;
30258 : TALLOC_CTX *mem_ctx;
30259 :
30260 0 : if (state->out_mem_ctx) {
30261 0 : mem_ctx = state->out_mem_ctx;
30262 : } else {
30263 0 : mem_ctx = state;
30264 : }
30265 :
30266 0 : status = dcerpc_clusapi_CreateGroupEx_r_recv(subreq, mem_ctx);
30267 0 : TALLOC_FREE(subreq);
30268 0 : if (tevent_req_nterror(req, status)) {
30269 0 : return;
30270 : }
30271 :
30272 : /* Copy out parameters */
30273 0 : *state->orig.out.Status = *state->tmp.out.Status;
30274 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
30275 0 : *state->orig.out.hGroup = *state->tmp.out.hGroup;
30276 :
30277 : /* Reset temporary structure */
30278 0 : NDR_ZERO_STRUCT(state->tmp);
30279 :
30280 0 : tevent_req_done(req);
30281 : }
30282 :
30283 0 : NTSTATUS dcerpc_clusapi_CreateGroupEx_recv(struct tevent_req *req,
30284 : TALLOC_CTX *mem_ctx)
30285 : {
30286 0 : struct dcerpc_clusapi_CreateGroupEx_state *state = tevent_req_data(
30287 : req, struct dcerpc_clusapi_CreateGroupEx_state);
30288 : NTSTATUS status;
30289 :
30290 0 : if (tevent_req_is_nterror(req, &status)) {
30291 0 : tevent_req_received(req);
30292 0 : return status;
30293 : }
30294 :
30295 : /* Steal possible out parameters to the callers context */
30296 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30297 :
30298 0 : tevent_req_received(req);
30299 0 : return NT_STATUS_OK;
30300 : }
30301 :
30302 0 : NTSTATUS dcerpc_clusapi_CreateGroupEx(struct dcerpc_binding_handle *h,
30303 : TALLOC_CTX *mem_ctx,
30304 : const char *_lpszGroupName /* [in] [charset(UTF16),ref] */,
30305 : struct CLUSTER_CREATE_GROUP_INFO_RPC *_pGroupInfo /* [in] [unique] */,
30306 : WERROR *_Status /* [out] [ref] */,
30307 : WERROR *_rpc_status /* [out] [ref] */,
30308 : struct policy_handle *_hGroup /* [out] [ref] */)
30309 : {
30310 : struct clusapi_CreateGroupEx r;
30311 : NTSTATUS status;
30312 :
30313 : /* In parameters */
30314 0 : r.in.lpszGroupName = _lpszGroupName;
30315 0 : r.in.pGroupInfo = _pGroupInfo;
30316 :
30317 : /* Out parameters */
30318 0 : r.out.Status = _Status;
30319 0 : r.out.rpc_status = _rpc_status;
30320 0 : r.out.hGroup = _hGroup;
30321 :
30322 0 : status = dcerpc_clusapi_CreateGroupEx_r(h, mem_ctx, &r);
30323 0 : if (!NT_STATUS_IS_OK(status)) {
30324 0 : return status;
30325 : }
30326 :
30327 : /* Return variables */
30328 0 : *_Status = *r.out.Status;
30329 0 : *_rpc_status = *r.out.rpc_status;
30330 0 : *_hGroup = *r.out.hGroup;
30331 :
30332 : /* Return result */
30333 :
30334 0 : return NT_STATUS_OK;
30335 : }
30336 :
30337 : struct dcerpc_clusapi_OnlineGroupEx_r_state {
30338 : TALLOC_CTX *out_mem_ctx;
30339 : };
30340 :
30341 : static void dcerpc_clusapi_OnlineGroupEx_r_done(struct tevent_req *subreq);
30342 :
30343 0 : struct tevent_req *dcerpc_clusapi_OnlineGroupEx_r_send(TALLOC_CTX *mem_ctx,
30344 : struct tevent_context *ev,
30345 : struct dcerpc_binding_handle *h,
30346 : struct clusapi_OnlineGroupEx *r)
30347 : {
30348 : struct tevent_req *req;
30349 : struct dcerpc_clusapi_OnlineGroupEx_r_state *state;
30350 : struct tevent_req *subreq;
30351 :
30352 0 : req = tevent_req_create(mem_ctx, &state,
30353 : struct dcerpc_clusapi_OnlineGroupEx_r_state);
30354 0 : if (req == NULL) {
30355 0 : return NULL;
30356 : }
30357 :
30358 0 : state->out_mem_ctx = talloc_new(state);
30359 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30360 0 : return tevent_req_post(req, ev);
30361 : }
30362 :
30363 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
30364 : NULL, &ndr_table_clusapi,
30365 0 : NDR_CLUSAPI_ONLINEGROUPEX, state->out_mem_ctx, r);
30366 0 : if (tevent_req_nomem(subreq, req)) {
30367 0 : return tevent_req_post(req, ev);
30368 : }
30369 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineGroupEx_r_done, req);
30370 :
30371 0 : return req;
30372 : }
30373 :
30374 0 : static void dcerpc_clusapi_OnlineGroupEx_r_done(struct tevent_req *subreq)
30375 : {
30376 0 : struct tevent_req *req =
30377 0 : tevent_req_callback_data(subreq,
30378 : struct tevent_req);
30379 : NTSTATUS status;
30380 :
30381 0 : status = dcerpc_binding_handle_call_recv(subreq);
30382 0 : TALLOC_FREE(subreq);
30383 0 : if (tevent_req_nterror(req, status)) {
30384 0 : return;
30385 : }
30386 :
30387 0 : tevent_req_done(req);
30388 : }
30389 :
30390 0 : NTSTATUS dcerpc_clusapi_OnlineGroupEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
30391 : {
30392 0 : struct dcerpc_clusapi_OnlineGroupEx_r_state *state =
30393 0 : tevent_req_data(req,
30394 : struct dcerpc_clusapi_OnlineGroupEx_r_state);
30395 : NTSTATUS status;
30396 :
30397 0 : if (tevent_req_is_nterror(req, &status)) {
30398 0 : tevent_req_received(req);
30399 0 : return status;
30400 : }
30401 :
30402 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30403 :
30404 0 : tevent_req_received(req);
30405 0 : return NT_STATUS_OK;
30406 : }
30407 :
30408 0 : NTSTATUS dcerpc_clusapi_OnlineGroupEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OnlineGroupEx *r)
30409 : {
30410 : NTSTATUS status;
30411 :
30412 0 : status = dcerpc_binding_handle_call(h,
30413 : NULL, &ndr_table_clusapi,
30414 : NDR_CLUSAPI_ONLINEGROUPEX, mem_ctx, r);
30415 :
30416 0 : return status;
30417 : }
30418 :
30419 : struct dcerpc_clusapi_OnlineGroupEx_state {
30420 : struct clusapi_OnlineGroupEx orig;
30421 : struct clusapi_OnlineGroupEx tmp;
30422 : TALLOC_CTX *out_mem_ctx;
30423 : };
30424 :
30425 : static void dcerpc_clusapi_OnlineGroupEx_done(struct tevent_req *subreq);
30426 :
30427 0 : struct tevent_req *dcerpc_clusapi_OnlineGroupEx_send(TALLOC_CTX *mem_ctx,
30428 : struct tevent_context *ev,
30429 : struct dcerpc_binding_handle *h,
30430 : struct policy_handle _hGroup /* [in] */,
30431 : uint32_t _dwOnlineFlags /* [in] */,
30432 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
30433 : uint32_t _cbInBufferSize /* [in] */,
30434 : WERROR *_rpc_status /* [out] [ref] */)
30435 : {
30436 : struct tevent_req *req;
30437 : struct dcerpc_clusapi_OnlineGroupEx_state *state;
30438 : struct tevent_req *subreq;
30439 :
30440 0 : req = tevent_req_create(mem_ctx, &state,
30441 : struct dcerpc_clusapi_OnlineGroupEx_state);
30442 0 : if (req == NULL) {
30443 0 : return NULL;
30444 : }
30445 0 : state->out_mem_ctx = NULL;
30446 :
30447 : /* In parameters */
30448 0 : state->orig.in.hGroup = _hGroup;
30449 0 : state->orig.in.dwOnlineFlags = _dwOnlineFlags;
30450 0 : state->orig.in.lpInBuffer = _lpInBuffer;
30451 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
30452 :
30453 : /* Out parameters */
30454 0 : state->orig.out.rpc_status = _rpc_status;
30455 :
30456 : /* Result */
30457 0 : NDR_ZERO_STRUCT(state->orig.out.result);
30458 :
30459 0 : state->out_mem_ctx = talloc_named_const(state, 0,
30460 : "dcerpc_clusapi_OnlineGroupEx_out_memory");
30461 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30462 0 : return tevent_req_post(req, ev);
30463 : }
30464 :
30465 : /* make a temporary copy, that we pass to the dispatch function */
30466 0 : state->tmp = state->orig;
30467 :
30468 0 : subreq = dcerpc_clusapi_OnlineGroupEx_r_send(state, ev, h, &state->tmp);
30469 0 : if (tevent_req_nomem(subreq, req)) {
30470 0 : return tevent_req_post(req, ev);
30471 : }
30472 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineGroupEx_done, req);
30473 0 : return req;
30474 : }
30475 :
30476 0 : static void dcerpc_clusapi_OnlineGroupEx_done(struct tevent_req *subreq)
30477 : {
30478 0 : struct tevent_req *req = tevent_req_callback_data(
30479 : subreq, struct tevent_req);
30480 0 : struct dcerpc_clusapi_OnlineGroupEx_state *state = tevent_req_data(
30481 : req, struct dcerpc_clusapi_OnlineGroupEx_state);
30482 : NTSTATUS status;
30483 : TALLOC_CTX *mem_ctx;
30484 :
30485 0 : if (state->out_mem_ctx) {
30486 0 : mem_ctx = state->out_mem_ctx;
30487 : } else {
30488 0 : mem_ctx = state;
30489 : }
30490 :
30491 0 : status = dcerpc_clusapi_OnlineGroupEx_r_recv(subreq, mem_ctx);
30492 0 : TALLOC_FREE(subreq);
30493 0 : if (tevent_req_nterror(req, status)) {
30494 0 : return;
30495 : }
30496 :
30497 : /* Copy out parameters */
30498 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
30499 :
30500 : /* Copy result */
30501 0 : state->orig.out.result = state->tmp.out.result;
30502 :
30503 : /* Reset temporary structure */
30504 0 : NDR_ZERO_STRUCT(state->tmp);
30505 :
30506 0 : tevent_req_done(req);
30507 : }
30508 :
30509 0 : NTSTATUS dcerpc_clusapi_OnlineGroupEx_recv(struct tevent_req *req,
30510 : TALLOC_CTX *mem_ctx,
30511 : WERROR *result)
30512 : {
30513 0 : struct dcerpc_clusapi_OnlineGroupEx_state *state = tevent_req_data(
30514 : req, struct dcerpc_clusapi_OnlineGroupEx_state);
30515 : NTSTATUS status;
30516 :
30517 0 : if (tevent_req_is_nterror(req, &status)) {
30518 0 : tevent_req_received(req);
30519 0 : return status;
30520 : }
30521 :
30522 : /* Steal possible out parameters to the callers context */
30523 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30524 :
30525 : /* Return result */
30526 0 : *result = state->orig.out.result;
30527 :
30528 0 : tevent_req_received(req);
30529 0 : return NT_STATUS_OK;
30530 : }
30531 :
30532 0 : NTSTATUS dcerpc_clusapi_OnlineGroupEx(struct dcerpc_binding_handle *h,
30533 : TALLOC_CTX *mem_ctx,
30534 : struct policy_handle _hGroup /* [in] */,
30535 : uint32_t _dwOnlineFlags /* [in] */,
30536 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
30537 : uint32_t _cbInBufferSize /* [in] */,
30538 : WERROR *_rpc_status /* [out] [ref] */,
30539 : WERROR *result)
30540 : {
30541 : struct clusapi_OnlineGroupEx r;
30542 : NTSTATUS status;
30543 :
30544 : /* In parameters */
30545 0 : r.in.hGroup = _hGroup;
30546 0 : r.in.dwOnlineFlags = _dwOnlineFlags;
30547 0 : r.in.lpInBuffer = _lpInBuffer;
30548 0 : r.in.cbInBufferSize = _cbInBufferSize;
30549 :
30550 : /* Out parameters */
30551 0 : r.out.rpc_status = _rpc_status;
30552 :
30553 : /* Result */
30554 0 : NDR_ZERO_STRUCT(r.out.result);
30555 :
30556 0 : status = dcerpc_clusapi_OnlineGroupEx_r(h, mem_ctx, &r);
30557 0 : if (!NT_STATUS_IS_OK(status)) {
30558 0 : return status;
30559 : }
30560 :
30561 : /* Return variables */
30562 0 : *_rpc_status = *r.out.rpc_status;
30563 :
30564 : /* Return result */
30565 0 : *result = r.out.result;
30566 :
30567 0 : return NT_STATUS_OK;
30568 : }
30569 :
30570 : struct dcerpc_clusapi_OfflineGroupEx_r_state {
30571 : TALLOC_CTX *out_mem_ctx;
30572 : };
30573 :
30574 : static void dcerpc_clusapi_OfflineGroupEx_r_done(struct tevent_req *subreq);
30575 :
30576 0 : struct tevent_req *dcerpc_clusapi_OfflineGroupEx_r_send(TALLOC_CTX *mem_ctx,
30577 : struct tevent_context *ev,
30578 : struct dcerpc_binding_handle *h,
30579 : struct clusapi_OfflineGroupEx *r)
30580 : {
30581 : struct tevent_req *req;
30582 : struct dcerpc_clusapi_OfflineGroupEx_r_state *state;
30583 : struct tevent_req *subreq;
30584 :
30585 0 : req = tevent_req_create(mem_ctx, &state,
30586 : struct dcerpc_clusapi_OfflineGroupEx_r_state);
30587 0 : if (req == NULL) {
30588 0 : return NULL;
30589 : }
30590 :
30591 0 : state->out_mem_ctx = talloc_new(state);
30592 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30593 0 : return tevent_req_post(req, ev);
30594 : }
30595 :
30596 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
30597 : NULL, &ndr_table_clusapi,
30598 0 : NDR_CLUSAPI_OFFLINEGROUPEX, state->out_mem_ctx, r);
30599 0 : if (tevent_req_nomem(subreq, req)) {
30600 0 : return tevent_req_post(req, ev);
30601 : }
30602 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineGroupEx_r_done, req);
30603 :
30604 0 : return req;
30605 : }
30606 :
30607 0 : static void dcerpc_clusapi_OfflineGroupEx_r_done(struct tevent_req *subreq)
30608 : {
30609 0 : struct tevent_req *req =
30610 0 : tevent_req_callback_data(subreq,
30611 : struct tevent_req);
30612 : NTSTATUS status;
30613 :
30614 0 : status = dcerpc_binding_handle_call_recv(subreq);
30615 0 : TALLOC_FREE(subreq);
30616 0 : if (tevent_req_nterror(req, status)) {
30617 0 : return;
30618 : }
30619 :
30620 0 : tevent_req_done(req);
30621 : }
30622 :
30623 0 : NTSTATUS dcerpc_clusapi_OfflineGroupEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
30624 : {
30625 0 : struct dcerpc_clusapi_OfflineGroupEx_r_state *state =
30626 0 : tevent_req_data(req,
30627 : struct dcerpc_clusapi_OfflineGroupEx_r_state);
30628 : NTSTATUS status;
30629 :
30630 0 : if (tevent_req_is_nterror(req, &status)) {
30631 0 : tevent_req_received(req);
30632 0 : return status;
30633 : }
30634 :
30635 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30636 :
30637 0 : tevent_req_received(req);
30638 0 : return NT_STATUS_OK;
30639 : }
30640 :
30641 0 : NTSTATUS dcerpc_clusapi_OfflineGroupEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OfflineGroupEx *r)
30642 : {
30643 : NTSTATUS status;
30644 :
30645 0 : status = dcerpc_binding_handle_call(h,
30646 : NULL, &ndr_table_clusapi,
30647 : NDR_CLUSAPI_OFFLINEGROUPEX, mem_ctx, r);
30648 :
30649 0 : return status;
30650 : }
30651 :
30652 : struct dcerpc_clusapi_OfflineGroupEx_state {
30653 : struct clusapi_OfflineGroupEx orig;
30654 : struct clusapi_OfflineGroupEx tmp;
30655 : TALLOC_CTX *out_mem_ctx;
30656 : };
30657 :
30658 : static void dcerpc_clusapi_OfflineGroupEx_done(struct tevent_req *subreq);
30659 :
30660 0 : struct tevent_req *dcerpc_clusapi_OfflineGroupEx_send(TALLOC_CTX *mem_ctx,
30661 : struct tevent_context *ev,
30662 : struct dcerpc_binding_handle *h,
30663 : struct policy_handle _hGroup /* [in] */,
30664 : uint32_t _dwOfflineFlags /* [in] */,
30665 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
30666 : uint32_t _cbInBufferSize /* [in] */,
30667 : WERROR *_rpc_status /* [out] [ref] */)
30668 : {
30669 : struct tevent_req *req;
30670 : struct dcerpc_clusapi_OfflineGroupEx_state *state;
30671 : struct tevent_req *subreq;
30672 :
30673 0 : req = tevent_req_create(mem_ctx, &state,
30674 : struct dcerpc_clusapi_OfflineGroupEx_state);
30675 0 : if (req == NULL) {
30676 0 : return NULL;
30677 : }
30678 0 : state->out_mem_ctx = NULL;
30679 :
30680 : /* In parameters */
30681 0 : state->orig.in.hGroup = _hGroup;
30682 0 : state->orig.in.dwOfflineFlags = _dwOfflineFlags;
30683 0 : state->orig.in.lpInBuffer = _lpInBuffer;
30684 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
30685 :
30686 : /* Out parameters */
30687 0 : state->orig.out.rpc_status = _rpc_status;
30688 :
30689 : /* Result */
30690 0 : NDR_ZERO_STRUCT(state->orig.out.result);
30691 :
30692 0 : state->out_mem_ctx = talloc_named_const(state, 0,
30693 : "dcerpc_clusapi_OfflineGroupEx_out_memory");
30694 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30695 0 : return tevent_req_post(req, ev);
30696 : }
30697 :
30698 : /* make a temporary copy, that we pass to the dispatch function */
30699 0 : state->tmp = state->orig;
30700 :
30701 0 : subreq = dcerpc_clusapi_OfflineGroupEx_r_send(state, ev, h, &state->tmp);
30702 0 : if (tevent_req_nomem(subreq, req)) {
30703 0 : return tevent_req_post(req, ev);
30704 : }
30705 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineGroupEx_done, req);
30706 0 : return req;
30707 : }
30708 :
30709 0 : static void dcerpc_clusapi_OfflineGroupEx_done(struct tevent_req *subreq)
30710 : {
30711 0 : struct tevent_req *req = tevent_req_callback_data(
30712 : subreq, struct tevent_req);
30713 0 : struct dcerpc_clusapi_OfflineGroupEx_state *state = tevent_req_data(
30714 : req, struct dcerpc_clusapi_OfflineGroupEx_state);
30715 : NTSTATUS status;
30716 : TALLOC_CTX *mem_ctx;
30717 :
30718 0 : if (state->out_mem_ctx) {
30719 0 : mem_ctx = state->out_mem_ctx;
30720 : } else {
30721 0 : mem_ctx = state;
30722 : }
30723 :
30724 0 : status = dcerpc_clusapi_OfflineGroupEx_r_recv(subreq, mem_ctx);
30725 0 : TALLOC_FREE(subreq);
30726 0 : if (tevent_req_nterror(req, status)) {
30727 0 : return;
30728 : }
30729 :
30730 : /* Copy out parameters */
30731 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
30732 :
30733 : /* Copy result */
30734 0 : state->orig.out.result = state->tmp.out.result;
30735 :
30736 : /* Reset temporary structure */
30737 0 : NDR_ZERO_STRUCT(state->tmp);
30738 :
30739 0 : tevent_req_done(req);
30740 : }
30741 :
30742 0 : NTSTATUS dcerpc_clusapi_OfflineGroupEx_recv(struct tevent_req *req,
30743 : TALLOC_CTX *mem_ctx,
30744 : WERROR *result)
30745 : {
30746 0 : struct dcerpc_clusapi_OfflineGroupEx_state *state = tevent_req_data(
30747 : req, struct dcerpc_clusapi_OfflineGroupEx_state);
30748 : NTSTATUS status;
30749 :
30750 0 : if (tevent_req_is_nterror(req, &status)) {
30751 0 : tevent_req_received(req);
30752 0 : return status;
30753 : }
30754 :
30755 : /* Steal possible out parameters to the callers context */
30756 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30757 :
30758 : /* Return result */
30759 0 : *result = state->orig.out.result;
30760 :
30761 0 : tevent_req_received(req);
30762 0 : return NT_STATUS_OK;
30763 : }
30764 :
30765 0 : NTSTATUS dcerpc_clusapi_OfflineGroupEx(struct dcerpc_binding_handle *h,
30766 : TALLOC_CTX *mem_ctx,
30767 : struct policy_handle _hGroup /* [in] */,
30768 : uint32_t _dwOfflineFlags /* [in] */,
30769 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
30770 : uint32_t _cbInBufferSize /* [in] */,
30771 : WERROR *_rpc_status /* [out] [ref] */,
30772 : WERROR *result)
30773 : {
30774 : struct clusapi_OfflineGroupEx r;
30775 : NTSTATUS status;
30776 :
30777 : /* In parameters */
30778 0 : r.in.hGroup = _hGroup;
30779 0 : r.in.dwOfflineFlags = _dwOfflineFlags;
30780 0 : r.in.lpInBuffer = _lpInBuffer;
30781 0 : r.in.cbInBufferSize = _cbInBufferSize;
30782 :
30783 : /* Out parameters */
30784 0 : r.out.rpc_status = _rpc_status;
30785 :
30786 : /* Result */
30787 0 : NDR_ZERO_STRUCT(r.out.result);
30788 :
30789 0 : status = dcerpc_clusapi_OfflineGroupEx_r(h, mem_ctx, &r);
30790 0 : if (!NT_STATUS_IS_OK(status)) {
30791 0 : return status;
30792 : }
30793 :
30794 : /* Return variables */
30795 0 : *_rpc_status = *r.out.rpc_status;
30796 :
30797 : /* Return result */
30798 0 : *result = r.out.result;
30799 :
30800 0 : return NT_STATUS_OK;
30801 : }
30802 :
30803 : struct dcerpc_clusapi_MoveGroupEx_r_state {
30804 : TALLOC_CTX *out_mem_ctx;
30805 : };
30806 :
30807 : static void dcerpc_clusapi_MoveGroupEx_r_done(struct tevent_req *subreq);
30808 :
30809 0 : struct tevent_req *dcerpc_clusapi_MoveGroupEx_r_send(TALLOC_CTX *mem_ctx,
30810 : struct tevent_context *ev,
30811 : struct dcerpc_binding_handle *h,
30812 : struct clusapi_MoveGroupEx *r)
30813 : {
30814 : struct tevent_req *req;
30815 : struct dcerpc_clusapi_MoveGroupEx_r_state *state;
30816 : struct tevent_req *subreq;
30817 :
30818 0 : req = tevent_req_create(mem_ctx, &state,
30819 : struct dcerpc_clusapi_MoveGroupEx_r_state);
30820 0 : if (req == NULL) {
30821 0 : return NULL;
30822 : }
30823 :
30824 0 : state->out_mem_ctx = talloc_new(state);
30825 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30826 0 : return tevent_req_post(req, ev);
30827 : }
30828 :
30829 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
30830 : NULL, &ndr_table_clusapi,
30831 0 : NDR_CLUSAPI_MOVEGROUPEX, state->out_mem_ctx, r);
30832 0 : if (tevent_req_nomem(subreq, req)) {
30833 0 : return tevent_req_post(req, ev);
30834 : }
30835 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupEx_r_done, req);
30836 :
30837 0 : return req;
30838 : }
30839 :
30840 0 : static void dcerpc_clusapi_MoveGroupEx_r_done(struct tevent_req *subreq)
30841 : {
30842 0 : struct tevent_req *req =
30843 0 : tevent_req_callback_data(subreq,
30844 : struct tevent_req);
30845 : NTSTATUS status;
30846 :
30847 0 : status = dcerpc_binding_handle_call_recv(subreq);
30848 0 : TALLOC_FREE(subreq);
30849 0 : if (tevent_req_nterror(req, status)) {
30850 0 : return;
30851 : }
30852 :
30853 0 : tevent_req_done(req);
30854 : }
30855 :
30856 0 : NTSTATUS dcerpc_clusapi_MoveGroupEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
30857 : {
30858 0 : struct dcerpc_clusapi_MoveGroupEx_r_state *state =
30859 0 : tevent_req_data(req,
30860 : struct dcerpc_clusapi_MoveGroupEx_r_state);
30861 : NTSTATUS status;
30862 :
30863 0 : if (tevent_req_is_nterror(req, &status)) {
30864 0 : tevent_req_received(req);
30865 0 : return status;
30866 : }
30867 :
30868 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30869 :
30870 0 : tevent_req_received(req);
30871 0 : return NT_STATUS_OK;
30872 : }
30873 :
30874 0 : NTSTATUS dcerpc_clusapi_MoveGroupEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_MoveGroupEx *r)
30875 : {
30876 : NTSTATUS status;
30877 :
30878 0 : status = dcerpc_binding_handle_call(h,
30879 : NULL, &ndr_table_clusapi,
30880 : NDR_CLUSAPI_MOVEGROUPEX, mem_ctx, r);
30881 :
30882 0 : return status;
30883 : }
30884 :
30885 : struct dcerpc_clusapi_MoveGroupEx_state {
30886 : struct clusapi_MoveGroupEx orig;
30887 : struct clusapi_MoveGroupEx tmp;
30888 : TALLOC_CTX *out_mem_ctx;
30889 : };
30890 :
30891 : static void dcerpc_clusapi_MoveGroupEx_done(struct tevent_req *subreq);
30892 :
30893 0 : struct tevent_req *dcerpc_clusapi_MoveGroupEx_send(TALLOC_CTX *mem_ctx,
30894 : struct tevent_context *ev,
30895 : struct dcerpc_binding_handle *h,
30896 : struct policy_handle _hGroup /* [in] */,
30897 : uint32_t _dwMoveFlags /* [in] */,
30898 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
30899 : uint32_t _cbInBufferSize /* [in] */,
30900 : WERROR *_rpc_status /* [out] [ref] */)
30901 : {
30902 : struct tevent_req *req;
30903 : struct dcerpc_clusapi_MoveGroupEx_state *state;
30904 : struct tevent_req *subreq;
30905 :
30906 0 : req = tevent_req_create(mem_ctx, &state,
30907 : struct dcerpc_clusapi_MoveGroupEx_state);
30908 0 : if (req == NULL) {
30909 0 : return NULL;
30910 : }
30911 0 : state->out_mem_ctx = NULL;
30912 :
30913 : /* In parameters */
30914 0 : state->orig.in.hGroup = _hGroup;
30915 0 : state->orig.in.dwMoveFlags = _dwMoveFlags;
30916 0 : state->orig.in.lpInBuffer = _lpInBuffer;
30917 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
30918 :
30919 : /* Out parameters */
30920 0 : state->orig.out.rpc_status = _rpc_status;
30921 :
30922 : /* Result */
30923 0 : NDR_ZERO_STRUCT(state->orig.out.result);
30924 :
30925 0 : state->out_mem_ctx = talloc_named_const(state, 0,
30926 : "dcerpc_clusapi_MoveGroupEx_out_memory");
30927 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
30928 0 : return tevent_req_post(req, ev);
30929 : }
30930 :
30931 : /* make a temporary copy, that we pass to the dispatch function */
30932 0 : state->tmp = state->orig;
30933 :
30934 0 : subreq = dcerpc_clusapi_MoveGroupEx_r_send(state, ev, h, &state->tmp);
30935 0 : if (tevent_req_nomem(subreq, req)) {
30936 0 : return tevent_req_post(req, ev);
30937 : }
30938 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupEx_done, req);
30939 0 : return req;
30940 : }
30941 :
30942 0 : static void dcerpc_clusapi_MoveGroupEx_done(struct tevent_req *subreq)
30943 : {
30944 0 : struct tevent_req *req = tevent_req_callback_data(
30945 : subreq, struct tevent_req);
30946 0 : struct dcerpc_clusapi_MoveGroupEx_state *state = tevent_req_data(
30947 : req, struct dcerpc_clusapi_MoveGroupEx_state);
30948 : NTSTATUS status;
30949 : TALLOC_CTX *mem_ctx;
30950 :
30951 0 : if (state->out_mem_ctx) {
30952 0 : mem_ctx = state->out_mem_ctx;
30953 : } else {
30954 0 : mem_ctx = state;
30955 : }
30956 :
30957 0 : status = dcerpc_clusapi_MoveGroupEx_r_recv(subreq, mem_ctx);
30958 0 : TALLOC_FREE(subreq);
30959 0 : if (tevent_req_nterror(req, status)) {
30960 0 : return;
30961 : }
30962 :
30963 : /* Copy out parameters */
30964 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
30965 :
30966 : /* Copy result */
30967 0 : state->orig.out.result = state->tmp.out.result;
30968 :
30969 : /* Reset temporary structure */
30970 0 : NDR_ZERO_STRUCT(state->tmp);
30971 :
30972 0 : tevent_req_done(req);
30973 : }
30974 :
30975 0 : NTSTATUS dcerpc_clusapi_MoveGroupEx_recv(struct tevent_req *req,
30976 : TALLOC_CTX *mem_ctx,
30977 : WERROR *result)
30978 : {
30979 0 : struct dcerpc_clusapi_MoveGroupEx_state *state = tevent_req_data(
30980 : req, struct dcerpc_clusapi_MoveGroupEx_state);
30981 : NTSTATUS status;
30982 :
30983 0 : if (tevent_req_is_nterror(req, &status)) {
30984 0 : tevent_req_received(req);
30985 0 : return status;
30986 : }
30987 :
30988 : /* Steal possible out parameters to the callers context */
30989 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
30990 :
30991 : /* Return result */
30992 0 : *result = state->orig.out.result;
30993 :
30994 0 : tevent_req_received(req);
30995 0 : return NT_STATUS_OK;
30996 : }
30997 :
30998 0 : NTSTATUS dcerpc_clusapi_MoveGroupEx(struct dcerpc_binding_handle *h,
30999 : TALLOC_CTX *mem_ctx,
31000 : struct policy_handle _hGroup /* [in] */,
31001 : uint32_t _dwMoveFlags /* [in] */,
31002 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31003 : uint32_t _cbInBufferSize /* [in] */,
31004 : WERROR *_rpc_status /* [out] [ref] */,
31005 : WERROR *result)
31006 : {
31007 : struct clusapi_MoveGroupEx r;
31008 : NTSTATUS status;
31009 :
31010 : /* In parameters */
31011 0 : r.in.hGroup = _hGroup;
31012 0 : r.in.dwMoveFlags = _dwMoveFlags;
31013 0 : r.in.lpInBuffer = _lpInBuffer;
31014 0 : r.in.cbInBufferSize = _cbInBufferSize;
31015 :
31016 : /* Out parameters */
31017 0 : r.out.rpc_status = _rpc_status;
31018 :
31019 : /* Result */
31020 0 : NDR_ZERO_STRUCT(r.out.result);
31021 :
31022 0 : status = dcerpc_clusapi_MoveGroupEx_r(h, mem_ctx, &r);
31023 0 : if (!NT_STATUS_IS_OK(status)) {
31024 0 : return status;
31025 : }
31026 :
31027 : /* Return variables */
31028 0 : *_rpc_status = *r.out.rpc_status;
31029 :
31030 : /* Return result */
31031 0 : *result = r.out.result;
31032 :
31033 0 : return NT_STATUS_OK;
31034 : }
31035 :
31036 : struct dcerpc_clusapi_MoveGroupToNodeEx_r_state {
31037 : TALLOC_CTX *out_mem_ctx;
31038 : };
31039 :
31040 : static void dcerpc_clusapi_MoveGroupToNodeEx_r_done(struct tevent_req *subreq);
31041 :
31042 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToNodeEx_r_send(TALLOC_CTX *mem_ctx,
31043 : struct tevent_context *ev,
31044 : struct dcerpc_binding_handle *h,
31045 : struct clusapi_MoveGroupToNodeEx *r)
31046 : {
31047 : struct tevent_req *req;
31048 : struct dcerpc_clusapi_MoveGroupToNodeEx_r_state *state;
31049 : struct tevent_req *subreq;
31050 :
31051 0 : req = tevent_req_create(mem_ctx, &state,
31052 : struct dcerpc_clusapi_MoveGroupToNodeEx_r_state);
31053 0 : if (req == NULL) {
31054 0 : return NULL;
31055 : }
31056 :
31057 0 : state->out_mem_ctx = talloc_new(state);
31058 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31059 0 : return tevent_req_post(req, ev);
31060 : }
31061 :
31062 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
31063 : NULL, &ndr_table_clusapi,
31064 0 : NDR_CLUSAPI_MOVEGROUPTONODEEX, state->out_mem_ctx, r);
31065 0 : if (tevent_req_nomem(subreq, req)) {
31066 0 : return tevent_req_post(req, ev);
31067 : }
31068 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToNodeEx_r_done, req);
31069 :
31070 0 : return req;
31071 : }
31072 :
31073 0 : static void dcerpc_clusapi_MoveGroupToNodeEx_r_done(struct tevent_req *subreq)
31074 : {
31075 0 : struct tevent_req *req =
31076 0 : tevent_req_callback_data(subreq,
31077 : struct tevent_req);
31078 : NTSTATUS status;
31079 :
31080 0 : status = dcerpc_binding_handle_call_recv(subreq);
31081 0 : TALLOC_FREE(subreq);
31082 0 : if (tevent_req_nterror(req, status)) {
31083 0 : return;
31084 : }
31085 :
31086 0 : tevent_req_done(req);
31087 : }
31088 :
31089 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNodeEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
31090 : {
31091 0 : struct dcerpc_clusapi_MoveGroupToNodeEx_r_state *state =
31092 0 : tevent_req_data(req,
31093 : struct dcerpc_clusapi_MoveGroupToNodeEx_r_state);
31094 : NTSTATUS status;
31095 :
31096 0 : if (tevent_req_is_nterror(req, &status)) {
31097 0 : tevent_req_received(req);
31098 0 : return status;
31099 : }
31100 :
31101 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31102 :
31103 0 : tevent_req_received(req);
31104 0 : return NT_STATUS_OK;
31105 : }
31106 :
31107 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNodeEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_MoveGroupToNodeEx *r)
31108 : {
31109 : NTSTATUS status;
31110 :
31111 0 : status = dcerpc_binding_handle_call(h,
31112 : NULL, &ndr_table_clusapi,
31113 : NDR_CLUSAPI_MOVEGROUPTONODEEX, mem_ctx, r);
31114 :
31115 0 : return status;
31116 : }
31117 :
31118 : struct dcerpc_clusapi_MoveGroupToNodeEx_state {
31119 : struct clusapi_MoveGroupToNodeEx orig;
31120 : struct clusapi_MoveGroupToNodeEx tmp;
31121 : TALLOC_CTX *out_mem_ctx;
31122 : };
31123 :
31124 : static void dcerpc_clusapi_MoveGroupToNodeEx_done(struct tevent_req *subreq);
31125 :
31126 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToNodeEx_send(TALLOC_CTX *mem_ctx,
31127 : struct tevent_context *ev,
31128 : struct dcerpc_binding_handle *h,
31129 : struct policy_handle _hGroup /* [in] */,
31130 : struct policy_handle _hNode /* [in] */,
31131 : uint32_t _dwMoveFlags /* [in] */,
31132 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31133 : uint32_t _cbInBufferSize /* [in] */,
31134 : WERROR *_rpc_status /* [out] [ref] */)
31135 : {
31136 : struct tevent_req *req;
31137 : struct dcerpc_clusapi_MoveGroupToNodeEx_state *state;
31138 : struct tevent_req *subreq;
31139 :
31140 0 : req = tevent_req_create(mem_ctx, &state,
31141 : struct dcerpc_clusapi_MoveGroupToNodeEx_state);
31142 0 : if (req == NULL) {
31143 0 : return NULL;
31144 : }
31145 0 : state->out_mem_ctx = NULL;
31146 :
31147 : /* In parameters */
31148 0 : state->orig.in.hGroup = _hGroup;
31149 0 : state->orig.in.hNode = _hNode;
31150 0 : state->orig.in.dwMoveFlags = _dwMoveFlags;
31151 0 : state->orig.in.lpInBuffer = _lpInBuffer;
31152 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
31153 :
31154 : /* Out parameters */
31155 0 : state->orig.out.rpc_status = _rpc_status;
31156 :
31157 : /* Result */
31158 0 : NDR_ZERO_STRUCT(state->orig.out.result);
31159 :
31160 0 : state->out_mem_ctx = talloc_named_const(state, 0,
31161 : "dcerpc_clusapi_MoveGroupToNodeEx_out_memory");
31162 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31163 0 : return tevent_req_post(req, ev);
31164 : }
31165 :
31166 : /* make a temporary copy, that we pass to the dispatch function */
31167 0 : state->tmp = state->orig;
31168 :
31169 0 : subreq = dcerpc_clusapi_MoveGroupToNodeEx_r_send(state, ev, h, &state->tmp);
31170 0 : if (tevent_req_nomem(subreq, req)) {
31171 0 : return tevent_req_post(req, ev);
31172 : }
31173 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToNodeEx_done, req);
31174 0 : return req;
31175 : }
31176 :
31177 0 : static void dcerpc_clusapi_MoveGroupToNodeEx_done(struct tevent_req *subreq)
31178 : {
31179 0 : struct tevent_req *req = tevent_req_callback_data(
31180 : subreq, struct tevent_req);
31181 0 : struct dcerpc_clusapi_MoveGroupToNodeEx_state *state = tevent_req_data(
31182 : req, struct dcerpc_clusapi_MoveGroupToNodeEx_state);
31183 : NTSTATUS status;
31184 : TALLOC_CTX *mem_ctx;
31185 :
31186 0 : if (state->out_mem_ctx) {
31187 0 : mem_ctx = state->out_mem_ctx;
31188 : } else {
31189 0 : mem_ctx = state;
31190 : }
31191 :
31192 0 : status = dcerpc_clusapi_MoveGroupToNodeEx_r_recv(subreq, mem_ctx);
31193 0 : TALLOC_FREE(subreq);
31194 0 : if (tevent_req_nterror(req, status)) {
31195 0 : return;
31196 : }
31197 :
31198 : /* Copy out parameters */
31199 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
31200 :
31201 : /* Copy result */
31202 0 : state->orig.out.result = state->tmp.out.result;
31203 :
31204 : /* Reset temporary structure */
31205 0 : NDR_ZERO_STRUCT(state->tmp);
31206 :
31207 0 : tevent_req_done(req);
31208 : }
31209 :
31210 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNodeEx_recv(struct tevent_req *req,
31211 : TALLOC_CTX *mem_ctx,
31212 : WERROR *result)
31213 : {
31214 0 : struct dcerpc_clusapi_MoveGroupToNodeEx_state *state = tevent_req_data(
31215 : req, struct dcerpc_clusapi_MoveGroupToNodeEx_state);
31216 : NTSTATUS status;
31217 :
31218 0 : if (tevent_req_is_nterror(req, &status)) {
31219 0 : tevent_req_received(req);
31220 0 : return status;
31221 : }
31222 :
31223 : /* Steal possible out parameters to the callers context */
31224 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31225 :
31226 : /* Return result */
31227 0 : *result = state->orig.out.result;
31228 :
31229 0 : tevent_req_received(req);
31230 0 : return NT_STATUS_OK;
31231 : }
31232 :
31233 0 : NTSTATUS dcerpc_clusapi_MoveGroupToNodeEx(struct dcerpc_binding_handle *h,
31234 : TALLOC_CTX *mem_ctx,
31235 : struct policy_handle _hGroup /* [in] */,
31236 : struct policy_handle _hNode /* [in] */,
31237 : uint32_t _dwMoveFlags /* [in] */,
31238 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31239 : uint32_t _cbInBufferSize /* [in] */,
31240 : WERROR *_rpc_status /* [out] [ref] */,
31241 : WERROR *result)
31242 : {
31243 : struct clusapi_MoveGroupToNodeEx r;
31244 : NTSTATUS status;
31245 :
31246 : /* In parameters */
31247 0 : r.in.hGroup = _hGroup;
31248 0 : r.in.hNode = _hNode;
31249 0 : r.in.dwMoveFlags = _dwMoveFlags;
31250 0 : r.in.lpInBuffer = _lpInBuffer;
31251 0 : r.in.cbInBufferSize = _cbInBufferSize;
31252 :
31253 : /* Out parameters */
31254 0 : r.out.rpc_status = _rpc_status;
31255 :
31256 : /* Result */
31257 0 : NDR_ZERO_STRUCT(r.out.result);
31258 :
31259 0 : status = dcerpc_clusapi_MoveGroupToNodeEx_r(h, mem_ctx, &r);
31260 0 : if (!NT_STATUS_IS_OK(status)) {
31261 0 : return status;
31262 : }
31263 :
31264 : /* Return variables */
31265 0 : *_rpc_status = *r.out.rpc_status;
31266 :
31267 : /* Return result */
31268 0 : *result = r.out.result;
31269 :
31270 0 : return NT_STATUS_OK;
31271 : }
31272 :
31273 : struct dcerpc_clusapi_CancelClusterGroupOperation_r_state {
31274 : TALLOC_CTX *out_mem_ctx;
31275 : };
31276 :
31277 : static void dcerpc_clusapi_CancelClusterGroupOperation_r_done(struct tevent_req *subreq);
31278 :
31279 0 : struct tevent_req *dcerpc_clusapi_CancelClusterGroupOperation_r_send(TALLOC_CTX *mem_ctx,
31280 : struct tevent_context *ev,
31281 : struct dcerpc_binding_handle *h,
31282 : struct clusapi_CancelClusterGroupOperation *r)
31283 : {
31284 : struct tevent_req *req;
31285 : struct dcerpc_clusapi_CancelClusterGroupOperation_r_state *state;
31286 : struct tevent_req *subreq;
31287 :
31288 0 : req = tevent_req_create(mem_ctx, &state,
31289 : struct dcerpc_clusapi_CancelClusterGroupOperation_r_state);
31290 0 : if (req == NULL) {
31291 0 : return NULL;
31292 : }
31293 :
31294 0 : state->out_mem_ctx = talloc_new(state);
31295 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31296 0 : return tevent_req_post(req, ev);
31297 : }
31298 :
31299 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
31300 : NULL, &ndr_table_clusapi,
31301 0 : NDR_CLUSAPI_CANCELCLUSTERGROUPOPERATION, state->out_mem_ctx, r);
31302 0 : if (tevent_req_nomem(subreq, req)) {
31303 0 : return tevent_req_post(req, ev);
31304 : }
31305 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CancelClusterGroupOperation_r_done, req);
31306 :
31307 0 : return req;
31308 : }
31309 :
31310 0 : static void dcerpc_clusapi_CancelClusterGroupOperation_r_done(struct tevent_req *subreq)
31311 : {
31312 0 : struct tevent_req *req =
31313 0 : tevent_req_callback_data(subreq,
31314 : struct tevent_req);
31315 : NTSTATUS status;
31316 :
31317 0 : status = dcerpc_binding_handle_call_recv(subreq);
31318 0 : TALLOC_FREE(subreq);
31319 0 : if (tevent_req_nterror(req, status)) {
31320 0 : return;
31321 : }
31322 :
31323 0 : tevent_req_done(req);
31324 : }
31325 :
31326 0 : NTSTATUS dcerpc_clusapi_CancelClusterGroupOperation_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
31327 : {
31328 0 : struct dcerpc_clusapi_CancelClusterGroupOperation_r_state *state =
31329 0 : tevent_req_data(req,
31330 : struct dcerpc_clusapi_CancelClusterGroupOperation_r_state);
31331 : NTSTATUS status;
31332 :
31333 0 : if (tevent_req_is_nterror(req, &status)) {
31334 0 : tevent_req_received(req);
31335 0 : return status;
31336 : }
31337 :
31338 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31339 :
31340 0 : tevent_req_received(req);
31341 0 : return NT_STATUS_OK;
31342 : }
31343 :
31344 0 : NTSTATUS dcerpc_clusapi_CancelClusterGroupOperation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CancelClusterGroupOperation *r)
31345 : {
31346 : NTSTATUS status;
31347 :
31348 0 : status = dcerpc_binding_handle_call(h,
31349 : NULL, &ndr_table_clusapi,
31350 : NDR_CLUSAPI_CANCELCLUSTERGROUPOPERATION, mem_ctx, r);
31351 :
31352 0 : return status;
31353 : }
31354 :
31355 : struct dcerpc_clusapi_CancelClusterGroupOperation_state {
31356 : struct clusapi_CancelClusterGroupOperation orig;
31357 : struct clusapi_CancelClusterGroupOperation tmp;
31358 : TALLOC_CTX *out_mem_ctx;
31359 : };
31360 :
31361 : static void dcerpc_clusapi_CancelClusterGroupOperation_done(struct tevent_req *subreq);
31362 :
31363 0 : struct tevent_req *dcerpc_clusapi_CancelClusterGroupOperation_send(TALLOC_CTX *mem_ctx,
31364 : struct tevent_context *ev,
31365 : struct dcerpc_binding_handle *h,
31366 : struct policy_handle _hGroup /* [in] */,
31367 : uint32_t _dwCancelFlags /* [in] */,
31368 : WERROR *_rpc_status /* [out] [ref] */)
31369 : {
31370 : struct tevent_req *req;
31371 : struct dcerpc_clusapi_CancelClusterGroupOperation_state *state;
31372 : struct tevent_req *subreq;
31373 :
31374 0 : req = tevent_req_create(mem_ctx, &state,
31375 : struct dcerpc_clusapi_CancelClusterGroupOperation_state);
31376 0 : if (req == NULL) {
31377 0 : return NULL;
31378 : }
31379 0 : state->out_mem_ctx = NULL;
31380 :
31381 : /* In parameters */
31382 0 : state->orig.in.hGroup = _hGroup;
31383 0 : state->orig.in.dwCancelFlags = _dwCancelFlags;
31384 :
31385 : /* Out parameters */
31386 0 : state->orig.out.rpc_status = _rpc_status;
31387 :
31388 : /* Result */
31389 0 : NDR_ZERO_STRUCT(state->orig.out.result);
31390 :
31391 0 : state->out_mem_ctx = talloc_named_const(state, 0,
31392 : "dcerpc_clusapi_CancelClusterGroupOperation_out_memory");
31393 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31394 0 : return tevent_req_post(req, ev);
31395 : }
31396 :
31397 : /* make a temporary copy, that we pass to the dispatch function */
31398 0 : state->tmp = state->orig;
31399 :
31400 0 : subreq = dcerpc_clusapi_CancelClusterGroupOperation_r_send(state, ev, h, &state->tmp);
31401 0 : if (tevent_req_nomem(subreq, req)) {
31402 0 : return tevent_req_post(req, ev);
31403 : }
31404 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CancelClusterGroupOperation_done, req);
31405 0 : return req;
31406 : }
31407 :
31408 0 : static void dcerpc_clusapi_CancelClusterGroupOperation_done(struct tevent_req *subreq)
31409 : {
31410 0 : struct tevent_req *req = tevent_req_callback_data(
31411 : subreq, struct tevent_req);
31412 0 : struct dcerpc_clusapi_CancelClusterGroupOperation_state *state = tevent_req_data(
31413 : req, struct dcerpc_clusapi_CancelClusterGroupOperation_state);
31414 : NTSTATUS status;
31415 : TALLOC_CTX *mem_ctx;
31416 :
31417 0 : if (state->out_mem_ctx) {
31418 0 : mem_ctx = state->out_mem_ctx;
31419 : } else {
31420 0 : mem_ctx = state;
31421 : }
31422 :
31423 0 : status = dcerpc_clusapi_CancelClusterGroupOperation_r_recv(subreq, mem_ctx);
31424 0 : TALLOC_FREE(subreq);
31425 0 : if (tevent_req_nterror(req, status)) {
31426 0 : return;
31427 : }
31428 :
31429 : /* Copy out parameters */
31430 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
31431 :
31432 : /* Copy result */
31433 0 : state->orig.out.result = state->tmp.out.result;
31434 :
31435 : /* Reset temporary structure */
31436 0 : NDR_ZERO_STRUCT(state->tmp);
31437 :
31438 0 : tevent_req_done(req);
31439 : }
31440 :
31441 0 : NTSTATUS dcerpc_clusapi_CancelClusterGroupOperation_recv(struct tevent_req *req,
31442 : TALLOC_CTX *mem_ctx,
31443 : WERROR *result)
31444 : {
31445 0 : struct dcerpc_clusapi_CancelClusterGroupOperation_state *state = tevent_req_data(
31446 : req, struct dcerpc_clusapi_CancelClusterGroupOperation_state);
31447 : NTSTATUS status;
31448 :
31449 0 : if (tevent_req_is_nterror(req, &status)) {
31450 0 : tevent_req_received(req);
31451 0 : return status;
31452 : }
31453 :
31454 : /* Steal possible out parameters to the callers context */
31455 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31456 :
31457 : /* Return result */
31458 0 : *result = state->orig.out.result;
31459 :
31460 0 : tevent_req_received(req);
31461 0 : return NT_STATUS_OK;
31462 : }
31463 :
31464 0 : NTSTATUS dcerpc_clusapi_CancelClusterGroupOperation(struct dcerpc_binding_handle *h,
31465 : TALLOC_CTX *mem_ctx,
31466 : struct policy_handle _hGroup /* [in] */,
31467 : uint32_t _dwCancelFlags /* [in] */,
31468 : WERROR *_rpc_status /* [out] [ref] */,
31469 : WERROR *result)
31470 : {
31471 : struct clusapi_CancelClusterGroupOperation r;
31472 : NTSTATUS status;
31473 :
31474 : /* In parameters */
31475 0 : r.in.hGroup = _hGroup;
31476 0 : r.in.dwCancelFlags = _dwCancelFlags;
31477 :
31478 : /* Out parameters */
31479 0 : r.out.rpc_status = _rpc_status;
31480 :
31481 : /* Result */
31482 0 : NDR_ZERO_STRUCT(r.out.result);
31483 :
31484 0 : status = dcerpc_clusapi_CancelClusterGroupOperation_r(h, mem_ctx, &r);
31485 0 : if (!NT_STATUS_IS_OK(status)) {
31486 0 : return status;
31487 : }
31488 :
31489 : /* Return variables */
31490 0 : *_rpc_status = *r.out.rpc_status;
31491 :
31492 : /* Return result */
31493 0 : *result = r.out.result;
31494 :
31495 0 : return NT_STATUS_OK;
31496 : }
31497 :
31498 : struct dcerpc_clusapi_OnlineResourceEx_r_state {
31499 : TALLOC_CTX *out_mem_ctx;
31500 : };
31501 :
31502 : static void dcerpc_clusapi_OnlineResourceEx_r_done(struct tevent_req *subreq);
31503 :
31504 0 : struct tevent_req *dcerpc_clusapi_OnlineResourceEx_r_send(TALLOC_CTX *mem_ctx,
31505 : struct tevent_context *ev,
31506 : struct dcerpc_binding_handle *h,
31507 : struct clusapi_OnlineResourceEx *r)
31508 : {
31509 : struct tevent_req *req;
31510 : struct dcerpc_clusapi_OnlineResourceEx_r_state *state;
31511 : struct tevent_req *subreq;
31512 :
31513 0 : req = tevent_req_create(mem_ctx, &state,
31514 : struct dcerpc_clusapi_OnlineResourceEx_r_state);
31515 0 : if (req == NULL) {
31516 0 : return NULL;
31517 : }
31518 :
31519 0 : state->out_mem_ctx = talloc_new(state);
31520 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31521 0 : return tevent_req_post(req, ev);
31522 : }
31523 :
31524 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
31525 : NULL, &ndr_table_clusapi,
31526 0 : NDR_CLUSAPI_ONLINERESOURCEEX, state->out_mem_ctx, r);
31527 0 : if (tevent_req_nomem(subreq, req)) {
31528 0 : return tevent_req_post(req, ev);
31529 : }
31530 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineResourceEx_r_done, req);
31531 :
31532 0 : return req;
31533 : }
31534 :
31535 0 : static void dcerpc_clusapi_OnlineResourceEx_r_done(struct tevent_req *subreq)
31536 : {
31537 0 : struct tevent_req *req =
31538 0 : tevent_req_callback_data(subreq,
31539 : struct tevent_req);
31540 : NTSTATUS status;
31541 :
31542 0 : status = dcerpc_binding_handle_call_recv(subreq);
31543 0 : TALLOC_FREE(subreq);
31544 0 : if (tevent_req_nterror(req, status)) {
31545 0 : return;
31546 : }
31547 :
31548 0 : tevent_req_done(req);
31549 : }
31550 :
31551 0 : NTSTATUS dcerpc_clusapi_OnlineResourceEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
31552 : {
31553 0 : struct dcerpc_clusapi_OnlineResourceEx_r_state *state =
31554 0 : tevent_req_data(req,
31555 : struct dcerpc_clusapi_OnlineResourceEx_r_state);
31556 : NTSTATUS status;
31557 :
31558 0 : if (tevent_req_is_nterror(req, &status)) {
31559 0 : tevent_req_received(req);
31560 0 : return status;
31561 : }
31562 :
31563 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31564 :
31565 0 : tevent_req_received(req);
31566 0 : return NT_STATUS_OK;
31567 : }
31568 :
31569 0 : NTSTATUS dcerpc_clusapi_OnlineResourceEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OnlineResourceEx *r)
31570 : {
31571 : NTSTATUS status;
31572 :
31573 0 : status = dcerpc_binding_handle_call(h,
31574 : NULL, &ndr_table_clusapi,
31575 : NDR_CLUSAPI_ONLINERESOURCEEX, mem_ctx, r);
31576 :
31577 0 : return status;
31578 : }
31579 :
31580 : struct dcerpc_clusapi_OnlineResourceEx_state {
31581 : struct clusapi_OnlineResourceEx orig;
31582 : struct clusapi_OnlineResourceEx tmp;
31583 : TALLOC_CTX *out_mem_ctx;
31584 : };
31585 :
31586 : static void dcerpc_clusapi_OnlineResourceEx_done(struct tevent_req *subreq);
31587 :
31588 0 : struct tevent_req *dcerpc_clusapi_OnlineResourceEx_send(TALLOC_CTX *mem_ctx,
31589 : struct tevent_context *ev,
31590 : struct dcerpc_binding_handle *h,
31591 : struct policy_handle _hResource /* [in] */,
31592 : uint32_t _dwOnlineFlags /* [in] */,
31593 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31594 : uint32_t _cbInBufferSize /* [in] */,
31595 : WERROR *_rpc_status /* [out] [ref] */)
31596 : {
31597 : struct tevent_req *req;
31598 : struct dcerpc_clusapi_OnlineResourceEx_state *state;
31599 : struct tevent_req *subreq;
31600 :
31601 0 : req = tevent_req_create(mem_ctx, &state,
31602 : struct dcerpc_clusapi_OnlineResourceEx_state);
31603 0 : if (req == NULL) {
31604 0 : return NULL;
31605 : }
31606 0 : state->out_mem_ctx = NULL;
31607 :
31608 : /* In parameters */
31609 0 : state->orig.in.hResource = _hResource;
31610 0 : state->orig.in.dwOnlineFlags = _dwOnlineFlags;
31611 0 : state->orig.in.lpInBuffer = _lpInBuffer;
31612 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
31613 :
31614 : /* Out parameters */
31615 0 : state->orig.out.rpc_status = _rpc_status;
31616 :
31617 : /* Result */
31618 0 : NDR_ZERO_STRUCT(state->orig.out.result);
31619 :
31620 0 : state->out_mem_ctx = talloc_named_const(state, 0,
31621 : "dcerpc_clusapi_OnlineResourceEx_out_memory");
31622 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31623 0 : return tevent_req_post(req, ev);
31624 : }
31625 :
31626 : /* make a temporary copy, that we pass to the dispatch function */
31627 0 : state->tmp = state->orig;
31628 :
31629 0 : subreq = dcerpc_clusapi_OnlineResourceEx_r_send(state, ev, h, &state->tmp);
31630 0 : if (tevent_req_nomem(subreq, req)) {
31631 0 : return tevent_req_post(req, ev);
31632 : }
31633 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OnlineResourceEx_done, req);
31634 0 : return req;
31635 : }
31636 :
31637 0 : static void dcerpc_clusapi_OnlineResourceEx_done(struct tevent_req *subreq)
31638 : {
31639 0 : struct tevent_req *req = tevent_req_callback_data(
31640 : subreq, struct tevent_req);
31641 0 : struct dcerpc_clusapi_OnlineResourceEx_state *state = tevent_req_data(
31642 : req, struct dcerpc_clusapi_OnlineResourceEx_state);
31643 : NTSTATUS status;
31644 : TALLOC_CTX *mem_ctx;
31645 :
31646 0 : if (state->out_mem_ctx) {
31647 0 : mem_ctx = state->out_mem_ctx;
31648 : } else {
31649 0 : mem_ctx = state;
31650 : }
31651 :
31652 0 : status = dcerpc_clusapi_OnlineResourceEx_r_recv(subreq, mem_ctx);
31653 0 : TALLOC_FREE(subreq);
31654 0 : if (tevent_req_nterror(req, status)) {
31655 0 : return;
31656 : }
31657 :
31658 : /* Copy out parameters */
31659 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
31660 :
31661 : /* Copy result */
31662 0 : state->orig.out.result = state->tmp.out.result;
31663 :
31664 : /* Reset temporary structure */
31665 0 : NDR_ZERO_STRUCT(state->tmp);
31666 :
31667 0 : tevent_req_done(req);
31668 : }
31669 :
31670 0 : NTSTATUS dcerpc_clusapi_OnlineResourceEx_recv(struct tevent_req *req,
31671 : TALLOC_CTX *mem_ctx,
31672 : WERROR *result)
31673 : {
31674 0 : struct dcerpc_clusapi_OnlineResourceEx_state *state = tevent_req_data(
31675 : req, struct dcerpc_clusapi_OnlineResourceEx_state);
31676 : NTSTATUS status;
31677 :
31678 0 : if (tevent_req_is_nterror(req, &status)) {
31679 0 : tevent_req_received(req);
31680 0 : return status;
31681 : }
31682 :
31683 : /* Steal possible out parameters to the callers context */
31684 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31685 :
31686 : /* Return result */
31687 0 : *result = state->orig.out.result;
31688 :
31689 0 : tevent_req_received(req);
31690 0 : return NT_STATUS_OK;
31691 : }
31692 :
31693 0 : NTSTATUS dcerpc_clusapi_OnlineResourceEx(struct dcerpc_binding_handle *h,
31694 : TALLOC_CTX *mem_ctx,
31695 : struct policy_handle _hResource /* [in] */,
31696 : uint32_t _dwOnlineFlags /* [in] */,
31697 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31698 : uint32_t _cbInBufferSize /* [in] */,
31699 : WERROR *_rpc_status /* [out] [ref] */,
31700 : WERROR *result)
31701 : {
31702 : struct clusapi_OnlineResourceEx r;
31703 : NTSTATUS status;
31704 :
31705 : /* In parameters */
31706 0 : r.in.hResource = _hResource;
31707 0 : r.in.dwOnlineFlags = _dwOnlineFlags;
31708 0 : r.in.lpInBuffer = _lpInBuffer;
31709 0 : r.in.cbInBufferSize = _cbInBufferSize;
31710 :
31711 : /* Out parameters */
31712 0 : r.out.rpc_status = _rpc_status;
31713 :
31714 : /* Result */
31715 0 : NDR_ZERO_STRUCT(r.out.result);
31716 :
31717 0 : status = dcerpc_clusapi_OnlineResourceEx_r(h, mem_ctx, &r);
31718 0 : if (!NT_STATUS_IS_OK(status)) {
31719 0 : return status;
31720 : }
31721 :
31722 : /* Return variables */
31723 0 : *_rpc_status = *r.out.rpc_status;
31724 :
31725 : /* Return result */
31726 0 : *result = r.out.result;
31727 :
31728 0 : return NT_STATUS_OK;
31729 : }
31730 :
31731 : struct dcerpc_clusapi_OfflineResourceEx_r_state {
31732 : TALLOC_CTX *out_mem_ctx;
31733 : };
31734 :
31735 : static void dcerpc_clusapi_OfflineResourceEx_r_done(struct tevent_req *subreq);
31736 :
31737 0 : struct tevent_req *dcerpc_clusapi_OfflineResourceEx_r_send(TALLOC_CTX *mem_ctx,
31738 : struct tevent_context *ev,
31739 : struct dcerpc_binding_handle *h,
31740 : struct clusapi_OfflineResourceEx *r)
31741 : {
31742 : struct tevent_req *req;
31743 : struct dcerpc_clusapi_OfflineResourceEx_r_state *state;
31744 : struct tevent_req *subreq;
31745 :
31746 0 : req = tevent_req_create(mem_ctx, &state,
31747 : struct dcerpc_clusapi_OfflineResourceEx_r_state);
31748 0 : if (req == NULL) {
31749 0 : return NULL;
31750 : }
31751 :
31752 0 : state->out_mem_ctx = talloc_new(state);
31753 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31754 0 : return tevent_req_post(req, ev);
31755 : }
31756 :
31757 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
31758 : NULL, &ndr_table_clusapi,
31759 0 : NDR_CLUSAPI_OFFLINERESOURCEEX, state->out_mem_ctx, r);
31760 0 : if (tevent_req_nomem(subreq, req)) {
31761 0 : return tevent_req_post(req, ev);
31762 : }
31763 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineResourceEx_r_done, req);
31764 :
31765 0 : return req;
31766 : }
31767 :
31768 0 : static void dcerpc_clusapi_OfflineResourceEx_r_done(struct tevent_req *subreq)
31769 : {
31770 0 : struct tevent_req *req =
31771 0 : tevent_req_callback_data(subreq,
31772 : struct tevent_req);
31773 : NTSTATUS status;
31774 :
31775 0 : status = dcerpc_binding_handle_call_recv(subreq);
31776 0 : TALLOC_FREE(subreq);
31777 0 : if (tevent_req_nterror(req, status)) {
31778 0 : return;
31779 : }
31780 :
31781 0 : tevent_req_done(req);
31782 : }
31783 :
31784 0 : NTSTATUS dcerpc_clusapi_OfflineResourceEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
31785 : {
31786 0 : struct dcerpc_clusapi_OfflineResourceEx_r_state *state =
31787 0 : tevent_req_data(req,
31788 : struct dcerpc_clusapi_OfflineResourceEx_r_state);
31789 : NTSTATUS status;
31790 :
31791 0 : if (tevent_req_is_nterror(req, &status)) {
31792 0 : tevent_req_received(req);
31793 0 : return status;
31794 : }
31795 :
31796 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31797 :
31798 0 : tevent_req_received(req);
31799 0 : return NT_STATUS_OK;
31800 : }
31801 :
31802 0 : NTSTATUS dcerpc_clusapi_OfflineResourceEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OfflineResourceEx *r)
31803 : {
31804 : NTSTATUS status;
31805 :
31806 0 : status = dcerpc_binding_handle_call(h,
31807 : NULL, &ndr_table_clusapi,
31808 : NDR_CLUSAPI_OFFLINERESOURCEEX, mem_ctx, r);
31809 :
31810 0 : return status;
31811 : }
31812 :
31813 : struct dcerpc_clusapi_OfflineResourceEx_state {
31814 : struct clusapi_OfflineResourceEx orig;
31815 : struct clusapi_OfflineResourceEx tmp;
31816 : TALLOC_CTX *out_mem_ctx;
31817 : };
31818 :
31819 : static void dcerpc_clusapi_OfflineResourceEx_done(struct tevent_req *subreq);
31820 :
31821 0 : struct tevent_req *dcerpc_clusapi_OfflineResourceEx_send(TALLOC_CTX *mem_ctx,
31822 : struct tevent_context *ev,
31823 : struct dcerpc_binding_handle *h,
31824 : struct policy_handle _hResource /* [in] */,
31825 : uint32_t _dwOfflineFlags /* [in] */,
31826 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31827 : uint32_t _cbInBufferSize /* [in] */,
31828 : WERROR *_rpc_status /* [out] [ref] */)
31829 : {
31830 : struct tevent_req *req;
31831 : struct dcerpc_clusapi_OfflineResourceEx_state *state;
31832 : struct tevent_req *subreq;
31833 :
31834 0 : req = tevent_req_create(mem_ctx, &state,
31835 : struct dcerpc_clusapi_OfflineResourceEx_state);
31836 0 : if (req == NULL) {
31837 0 : return NULL;
31838 : }
31839 0 : state->out_mem_ctx = NULL;
31840 :
31841 : /* In parameters */
31842 0 : state->orig.in.hResource = _hResource;
31843 0 : state->orig.in.dwOfflineFlags = _dwOfflineFlags;
31844 0 : state->orig.in.lpInBuffer = _lpInBuffer;
31845 0 : state->orig.in.cbInBufferSize = _cbInBufferSize;
31846 :
31847 : /* Out parameters */
31848 0 : state->orig.out.rpc_status = _rpc_status;
31849 :
31850 : /* Result */
31851 0 : NDR_ZERO_STRUCT(state->orig.out.result);
31852 :
31853 0 : state->out_mem_ctx = talloc_named_const(state, 0,
31854 : "dcerpc_clusapi_OfflineResourceEx_out_memory");
31855 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31856 0 : return tevent_req_post(req, ev);
31857 : }
31858 :
31859 : /* make a temporary copy, that we pass to the dispatch function */
31860 0 : state->tmp = state->orig;
31861 :
31862 0 : subreq = dcerpc_clusapi_OfflineResourceEx_r_send(state, ev, h, &state->tmp);
31863 0 : if (tevent_req_nomem(subreq, req)) {
31864 0 : return tevent_req_post(req, ev);
31865 : }
31866 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OfflineResourceEx_done, req);
31867 0 : return req;
31868 : }
31869 :
31870 0 : static void dcerpc_clusapi_OfflineResourceEx_done(struct tevent_req *subreq)
31871 : {
31872 0 : struct tevent_req *req = tevent_req_callback_data(
31873 : subreq, struct tevent_req);
31874 0 : struct dcerpc_clusapi_OfflineResourceEx_state *state = tevent_req_data(
31875 : req, struct dcerpc_clusapi_OfflineResourceEx_state);
31876 : NTSTATUS status;
31877 : TALLOC_CTX *mem_ctx;
31878 :
31879 0 : if (state->out_mem_ctx) {
31880 0 : mem_ctx = state->out_mem_ctx;
31881 : } else {
31882 0 : mem_ctx = state;
31883 : }
31884 :
31885 0 : status = dcerpc_clusapi_OfflineResourceEx_r_recv(subreq, mem_ctx);
31886 0 : TALLOC_FREE(subreq);
31887 0 : if (tevent_req_nterror(req, status)) {
31888 0 : return;
31889 : }
31890 :
31891 : /* Copy out parameters */
31892 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
31893 :
31894 : /* Copy result */
31895 0 : state->orig.out.result = state->tmp.out.result;
31896 :
31897 : /* Reset temporary structure */
31898 0 : NDR_ZERO_STRUCT(state->tmp);
31899 :
31900 0 : tevent_req_done(req);
31901 : }
31902 :
31903 0 : NTSTATUS dcerpc_clusapi_OfflineResourceEx_recv(struct tevent_req *req,
31904 : TALLOC_CTX *mem_ctx,
31905 : WERROR *result)
31906 : {
31907 0 : struct dcerpc_clusapi_OfflineResourceEx_state *state = tevent_req_data(
31908 : req, struct dcerpc_clusapi_OfflineResourceEx_state);
31909 : NTSTATUS status;
31910 :
31911 0 : if (tevent_req_is_nterror(req, &status)) {
31912 0 : tevent_req_received(req);
31913 0 : return status;
31914 : }
31915 :
31916 : /* Steal possible out parameters to the callers context */
31917 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
31918 :
31919 : /* Return result */
31920 0 : *result = state->orig.out.result;
31921 :
31922 0 : tevent_req_received(req);
31923 0 : return NT_STATUS_OK;
31924 : }
31925 :
31926 0 : NTSTATUS dcerpc_clusapi_OfflineResourceEx(struct dcerpc_binding_handle *h,
31927 : TALLOC_CTX *mem_ctx,
31928 : struct policy_handle _hResource /* [in] */,
31929 : uint32_t _dwOfflineFlags /* [in] */,
31930 : uint8_t *_lpInBuffer /* [in] [ref,size_is(cbInBufferSize)] */,
31931 : uint32_t _cbInBufferSize /* [in] */,
31932 : WERROR *_rpc_status /* [out] [ref] */,
31933 : WERROR *result)
31934 : {
31935 : struct clusapi_OfflineResourceEx r;
31936 : NTSTATUS status;
31937 :
31938 : /* In parameters */
31939 0 : r.in.hResource = _hResource;
31940 0 : r.in.dwOfflineFlags = _dwOfflineFlags;
31941 0 : r.in.lpInBuffer = _lpInBuffer;
31942 0 : r.in.cbInBufferSize = _cbInBufferSize;
31943 :
31944 : /* Out parameters */
31945 0 : r.out.rpc_status = _rpc_status;
31946 :
31947 : /* Result */
31948 0 : NDR_ZERO_STRUCT(r.out.result);
31949 :
31950 0 : status = dcerpc_clusapi_OfflineResourceEx_r(h, mem_ctx, &r);
31951 0 : if (!NT_STATUS_IS_OK(status)) {
31952 0 : return status;
31953 : }
31954 :
31955 : /* Return variables */
31956 0 : *_rpc_status = *r.out.rpc_status;
31957 :
31958 : /* Return result */
31959 0 : *result = r.out.result;
31960 :
31961 0 : return NT_STATUS_OK;
31962 : }
31963 :
31964 : struct dcerpc_clusapi_CreateNotifyV2_r_state {
31965 : TALLOC_CTX *out_mem_ctx;
31966 : };
31967 :
31968 : static void dcerpc_clusapi_CreateNotifyV2_r_done(struct tevent_req *subreq);
31969 :
31970 0 : struct tevent_req *dcerpc_clusapi_CreateNotifyV2_r_send(TALLOC_CTX *mem_ctx,
31971 : struct tevent_context *ev,
31972 : struct dcerpc_binding_handle *h,
31973 : struct clusapi_CreateNotifyV2 *r)
31974 : {
31975 : struct tevent_req *req;
31976 : struct dcerpc_clusapi_CreateNotifyV2_r_state *state;
31977 : struct tevent_req *subreq;
31978 :
31979 0 : req = tevent_req_create(mem_ctx, &state,
31980 : struct dcerpc_clusapi_CreateNotifyV2_r_state);
31981 0 : if (req == NULL) {
31982 0 : return NULL;
31983 : }
31984 :
31985 0 : state->out_mem_ctx = talloc_new(state);
31986 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
31987 0 : return tevent_req_post(req, ev);
31988 : }
31989 :
31990 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
31991 : NULL, &ndr_table_clusapi,
31992 0 : NDR_CLUSAPI_CREATENOTIFYV2, state->out_mem_ctx, r);
31993 0 : if (tevent_req_nomem(subreq, req)) {
31994 0 : return tevent_req_post(req, ev);
31995 : }
31996 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNotifyV2_r_done, req);
31997 :
31998 0 : return req;
31999 : }
32000 :
32001 0 : static void dcerpc_clusapi_CreateNotifyV2_r_done(struct tevent_req *subreq)
32002 : {
32003 0 : struct tevent_req *req =
32004 0 : tevent_req_callback_data(subreq,
32005 : struct tevent_req);
32006 : NTSTATUS status;
32007 :
32008 0 : status = dcerpc_binding_handle_call_recv(subreq);
32009 0 : TALLOC_FREE(subreq);
32010 0 : if (tevent_req_nterror(req, status)) {
32011 0 : return;
32012 : }
32013 :
32014 0 : tevent_req_done(req);
32015 : }
32016 :
32017 0 : NTSTATUS dcerpc_clusapi_CreateNotifyV2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
32018 : {
32019 0 : struct dcerpc_clusapi_CreateNotifyV2_r_state *state =
32020 0 : tevent_req_data(req,
32021 : struct dcerpc_clusapi_CreateNotifyV2_r_state);
32022 : NTSTATUS status;
32023 :
32024 0 : if (tevent_req_is_nterror(req, &status)) {
32025 0 : tevent_req_received(req);
32026 0 : return status;
32027 : }
32028 :
32029 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32030 :
32031 0 : tevent_req_received(req);
32032 0 : return NT_STATUS_OK;
32033 : }
32034 :
32035 0 : NTSTATUS dcerpc_clusapi_CreateNotifyV2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNotifyV2 *r)
32036 : {
32037 : NTSTATUS status;
32038 :
32039 0 : status = dcerpc_binding_handle_call(h,
32040 : NULL, &ndr_table_clusapi,
32041 : NDR_CLUSAPI_CREATENOTIFYV2, mem_ctx, r);
32042 :
32043 0 : return status;
32044 : }
32045 :
32046 : struct dcerpc_clusapi_CreateNotifyV2_state {
32047 : struct clusapi_CreateNotifyV2 orig;
32048 : struct clusapi_CreateNotifyV2 tmp;
32049 : TALLOC_CTX *out_mem_ctx;
32050 : };
32051 :
32052 : static void dcerpc_clusapi_CreateNotifyV2_done(struct tevent_req *subreq);
32053 :
32054 0 : struct tevent_req *dcerpc_clusapi_CreateNotifyV2_send(TALLOC_CTX *mem_ctx,
32055 : struct tevent_context *ev,
32056 : struct dcerpc_binding_handle *h,
32057 : WERROR *_rpc_error /* [out] [ref] */,
32058 : WERROR *_rpc_status /* [out] [ref] */,
32059 : struct policy_handle *_hNotify /* [out] [ref] */)
32060 : {
32061 : struct tevent_req *req;
32062 : struct dcerpc_clusapi_CreateNotifyV2_state *state;
32063 : struct tevent_req *subreq;
32064 :
32065 0 : req = tevent_req_create(mem_ctx, &state,
32066 : struct dcerpc_clusapi_CreateNotifyV2_state);
32067 0 : if (req == NULL) {
32068 0 : return NULL;
32069 : }
32070 0 : state->out_mem_ctx = NULL;
32071 :
32072 : /* In parameters */
32073 :
32074 : /* Out parameters */
32075 0 : state->orig.out.rpc_error = _rpc_error;
32076 0 : state->orig.out.rpc_status = _rpc_status;
32077 0 : state->orig.out.hNotify = _hNotify;
32078 :
32079 0 : state->out_mem_ctx = talloc_named_const(state, 0,
32080 : "dcerpc_clusapi_CreateNotifyV2_out_memory");
32081 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32082 0 : return tevent_req_post(req, ev);
32083 : }
32084 :
32085 : /* make a temporary copy, that we pass to the dispatch function */
32086 0 : state->tmp = state->orig;
32087 :
32088 0 : subreq = dcerpc_clusapi_CreateNotifyV2_r_send(state, ev, h, &state->tmp);
32089 0 : if (tevent_req_nomem(subreq, req)) {
32090 0 : return tevent_req_post(req, ev);
32091 : }
32092 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNotifyV2_done, req);
32093 0 : return req;
32094 : }
32095 :
32096 0 : static void dcerpc_clusapi_CreateNotifyV2_done(struct tevent_req *subreq)
32097 : {
32098 0 : struct tevent_req *req = tevent_req_callback_data(
32099 : subreq, struct tevent_req);
32100 0 : struct dcerpc_clusapi_CreateNotifyV2_state *state = tevent_req_data(
32101 : req, struct dcerpc_clusapi_CreateNotifyV2_state);
32102 : NTSTATUS status;
32103 : TALLOC_CTX *mem_ctx;
32104 :
32105 0 : if (state->out_mem_ctx) {
32106 0 : mem_ctx = state->out_mem_ctx;
32107 : } else {
32108 0 : mem_ctx = state;
32109 : }
32110 :
32111 0 : status = dcerpc_clusapi_CreateNotifyV2_r_recv(subreq, mem_ctx);
32112 0 : TALLOC_FREE(subreq);
32113 0 : if (tevent_req_nterror(req, status)) {
32114 0 : return;
32115 : }
32116 :
32117 : /* Copy out parameters */
32118 0 : *state->orig.out.rpc_error = *state->tmp.out.rpc_error;
32119 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
32120 0 : *state->orig.out.hNotify = *state->tmp.out.hNotify;
32121 :
32122 : /* Reset temporary structure */
32123 0 : NDR_ZERO_STRUCT(state->tmp);
32124 :
32125 0 : tevent_req_done(req);
32126 : }
32127 :
32128 0 : NTSTATUS dcerpc_clusapi_CreateNotifyV2_recv(struct tevent_req *req,
32129 : TALLOC_CTX *mem_ctx)
32130 : {
32131 0 : struct dcerpc_clusapi_CreateNotifyV2_state *state = tevent_req_data(
32132 : req, struct dcerpc_clusapi_CreateNotifyV2_state);
32133 : NTSTATUS status;
32134 :
32135 0 : if (tevent_req_is_nterror(req, &status)) {
32136 0 : tevent_req_received(req);
32137 0 : return status;
32138 : }
32139 :
32140 : /* Steal possible out parameters to the callers context */
32141 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32142 :
32143 0 : tevent_req_received(req);
32144 0 : return NT_STATUS_OK;
32145 : }
32146 :
32147 0 : NTSTATUS dcerpc_clusapi_CreateNotifyV2(struct dcerpc_binding_handle *h,
32148 : TALLOC_CTX *mem_ctx,
32149 : WERROR *_rpc_error /* [out] [ref] */,
32150 : WERROR *_rpc_status /* [out] [ref] */,
32151 : struct policy_handle *_hNotify /* [out] [ref] */)
32152 : {
32153 : struct clusapi_CreateNotifyV2 r;
32154 : NTSTATUS status;
32155 :
32156 : /* In parameters */
32157 :
32158 : /* Out parameters */
32159 0 : r.out.rpc_error = _rpc_error;
32160 0 : r.out.rpc_status = _rpc_status;
32161 0 : r.out.hNotify = _hNotify;
32162 :
32163 0 : status = dcerpc_clusapi_CreateNotifyV2_r(h, mem_ctx, &r);
32164 0 : if (!NT_STATUS_IS_OK(status)) {
32165 0 : return status;
32166 : }
32167 :
32168 : /* Return variables */
32169 0 : *_rpc_error = *r.out.rpc_error;
32170 0 : *_rpc_status = *r.out.rpc_status;
32171 0 : *_hNotify = *r.out.hNotify;
32172 :
32173 : /* Return result */
32174 :
32175 0 : return NT_STATUS_OK;
32176 : }
32177 :
32178 : struct dcerpc_clusapi_AddNotifyV2_r_state {
32179 : TALLOC_CTX *out_mem_ctx;
32180 : };
32181 :
32182 : static void dcerpc_clusapi_AddNotifyV2_r_done(struct tevent_req *subreq);
32183 :
32184 0 : struct tevent_req *dcerpc_clusapi_AddNotifyV2_r_send(TALLOC_CTX *mem_ctx,
32185 : struct tevent_context *ev,
32186 : struct dcerpc_binding_handle *h,
32187 : struct clusapi_AddNotifyV2 *r)
32188 : {
32189 : struct tevent_req *req;
32190 : struct dcerpc_clusapi_AddNotifyV2_r_state *state;
32191 : struct tevent_req *subreq;
32192 :
32193 0 : req = tevent_req_create(mem_ctx, &state,
32194 : struct dcerpc_clusapi_AddNotifyV2_r_state);
32195 0 : if (req == NULL) {
32196 0 : return NULL;
32197 : }
32198 :
32199 0 : state->out_mem_ctx = talloc_new(state);
32200 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32201 0 : return tevent_req_post(req, ev);
32202 : }
32203 :
32204 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
32205 : NULL, &ndr_table_clusapi,
32206 0 : NDR_CLUSAPI_ADDNOTIFYV2, state->out_mem_ctx, r);
32207 0 : if (tevent_req_nomem(subreq, req)) {
32208 0 : return tevent_req_post(req, ev);
32209 : }
32210 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyV2_r_done, req);
32211 :
32212 0 : return req;
32213 : }
32214 :
32215 0 : static void dcerpc_clusapi_AddNotifyV2_r_done(struct tevent_req *subreq)
32216 : {
32217 0 : struct tevent_req *req =
32218 0 : tevent_req_callback_data(subreq,
32219 : struct tevent_req);
32220 : NTSTATUS status;
32221 :
32222 0 : status = dcerpc_binding_handle_call_recv(subreq);
32223 0 : TALLOC_FREE(subreq);
32224 0 : if (tevent_req_nterror(req, status)) {
32225 0 : return;
32226 : }
32227 :
32228 0 : tevent_req_done(req);
32229 : }
32230 :
32231 0 : NTSTATUS dcerpc_clusapi_AddNotifyV2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
32232 : {
32233 0 : struct dcerpc_clusapi_AddNotifyV2_r_state *state =
32234 0 : tevent_req_data(req,
32235 : struct dcerpc_clusapi_AddNotifyV2_r_state);
32236 : NTSTATUS status;
32237 :
32238 0 : if (tevent_req_is_nterror(req, &status)) {
32239 0 : tevent_req_received(req);
32240 0 : return status;
32241 : }
32242 :
32243 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32244 :
32245 0 : tevent_req_received(req);
32246 0 : return NT_STATUS_OK;
32247 : }
32248 :
32249 0 : NTSTATUS dcerpc_clusapi_AddNotifyV2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyV2 *r)
32250 : {
32251 : NTSTATUS status;
32252 :
32253 0 : status = dcerpc_binding_handle_call(h,
32254 : NULL, &ndr_table_clusapi,
32255 : NDR_CLUSAPI_ADDNOTIFYV2, mem_ctx, r);
32256 :
32257 0 : return status;
32258 : }
32259 :
32260 : struct dcerpc_clusapi_AddNotifyV2_state {
32261 : struct clusapi_AddNotifyV2 orig;
32262 : struct clusapi_AddNotifyV2 tmp;
32263 : TALLOC_CTX *out_mem_ctx;
32264 : };
32265 :
32266 : static void dcerpc_clusapi_AddNotifyV2_done(struct tevent_req *subreq);
32267 :
32268 0 : struct tevent_req *dcerpc_clusapi_AddNotifyV2_send(TALLOC_CTX *mem_ctx,
32269 : struct tevent_context *ev,
32270 : struct dcerpc_binding_handle *h,
32271 : struct policy_handle _hNotify /* [in] */,
32272 : struct policy_handle _hObject /* [in] */,
32273 : struct NOTIFY_FILTER_AND_TYPE_RPC _filter /* [in] */,
32274 : uint32_t _dwNotifyKey /* [in] */,
32275 : uint32_t _dwVersion /* [in] */,
32276 : uint8_t _isTargetedAtObject /* [in] */,
32277 : WERROR *_rpc_status /* [out] [ref] */)
32278 : {
32279 : struct tevent_req *req;
32280 : struct dcerpc_clusapi_AddNotifyV2_state *state;
32281 : struct tevent_req *subreq;
32282 :
32283 0 : req = tevent_req_create(mem_ctx, &state,
32284 : struct dcerpc_clusapi_AddNotifyV2_state);
32285 0 : if (req == NULL) {
32286 0 : return NULL;
32287 : }
32288 0 : state->out_mem_ctx = NULL;
32289 :
32290 : /* In parameters */
32291 0 : state->orig.in.hNotify = _hNotify;
32292 0 : state->orig.in.hObject = _hObject;
32293 0 : state->orig.in.filter = _filter;
32294 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
32295 0 : state->orig.in.dwVersion = _dwVersion;
32296 0 : state->orig.in.isTargetedAtObject = _isTargetedAtObject;
32297 :
32298 : /* Out parameters */
32299 0 : state->orig.out.rpc_status = _rpc_status;
32300 :
32301 : /* Result */
32302 0 : NDR_ZERO_STRUCT(state->orig.out.result);
32303 :
32304 0 : state->out_mem_ctx = talloc_named_const(state, 0,
32305 : "dcerpc_clusapi_AddNotifyV2_out_memory");
32306 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32307 0 : return tevent_req_post(req, ev);
32308 : }
32309 :
32310 : /* make a temporary copy, that we pass to the dispatch function */
32311 0 : state->tmp = state->orig;
32312 :
32313 0 : subreq = dcerpc_clusapi_AddNotifyV2_r_send(state, ev, h, &state->tmp);
32314 0 : if (tevent_req_nomem(subreq, req)) {
32315 0 : return tevent_req_post(req, ev);
32316 : }
32317 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyV2_done, req);
32318 0 : return req;
32319 : }
32320 :
32321 0 : static void dcerpc_clusapi_AddNotifyV2_done(struct tevent_req *subreq)
32322 : {
32323 0 : struct tevent_req *req = tevent_req_callback_data(
32324 : subreq, struct tevent_req);
32325 0 : struct dcerpc_clusapi_AddNotifyV2_state *state = tevent_req_data(
32326 : req, struct dcerpc_clusapi_AddNotifyV2_state);
32327 : NTSTATUS status;
32328 : TALLOC_CTX *mem_ctx;
32329 :
32330 0 : if (state->out_mem_ctx) {
32331 0 : mem_ctx = state->out_mem_ctx;
32332 : } else {
32333 0 : mem_ctx = state;
32334 : }
32335 :
32336 0 : status = dcerpc_clusapi_AddNotifyV2_r_recv(subreq, mem_ctx);
32337 0 : TALLOC_FREE(subreq);
32338 0 : if (tevent_req_nterror(req, status)) {
32339 0 : return;
32340 : }
32341 :
32342 : /* Copy out parameters */
32343 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
32344 :
32345 : /* Copy result */
32346 0 : state->orig.out.result = state->tmp.out.result;
32347 :
32348 : /* Reset temporary structure */
32349 0 : NDR_ZERO_STRUCT(state->tmp);
32350 :
32351 0 : tevent_req_done(req);
32352 : }
32353 :
32354 0 : NTSTATUS dcerpc_clusapi_AddNotifyV2_recv(struct tevent_req *req,
32355 : TALLOC_CTX *mem_ctx,
32356 : WERROR *result)
32357 : {
32358 0 : struct dcerpc_clusapi_AddNotifyV2_state *state = tevent_req_data(
32359 : req, struct dcerpc_clusapi_AddNotifyV2_state);
32360 : NTSTATUS status;
32361 :
32362 0 : if (tevent_req_is_nterror(req, &status)) {
32363 0 : tevent_req_received(req);
32364 0 : return status;
32365 : }
32366 :
32367 : /* Steal possible out parameters to the callers context */
32368 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32369 :
32370 : /* Return result */
32371 0 : *result = state->orig.out.result;
32372 :
32373 0 : tevent_req_received(req);
32374 0 : return NT_STATUS_OK;
32375 : }
32376 :
32377 0 : NTSTATUS dcerpc_clusapi_AddNotifyV2(struct dcerpc_binding_handle *h,
32378 : TALLOC_CTX *mem_ctx,
32379 : struct policy_handle _hNotify /* [in] */,
32380 : struct policy_handle _hObject /* [in] */,
32381 : struct NOTIFY_FILTER_AND_TYPE_RPC _filter /* [in] */,
32382 : uint32_t _dwNotifyKey /* [in] */,
32383 : uint32_t _dwVersion /* [in] */,
32384 : uint8_t _isTargetedAtObject /* [in] */,
32385 : WERROR *_rpc_status /* [out] [ref] */,
32386 : WERROR *result)
32387 : {
32388 : struct clusapi_AddNotifyV2 r;
32389 : NTSTATUS status;
32390 :
32391 : /* In parameters */
32392 0 : r.in.hNotify = _hNotify;
32393 0 : r.in.hObject = _hObject;
32394 0 : r.in.filter = _filter;
32395 0 : r.in.dwNotifyKey = _dwNotifyKey;
32396 0 : r.in.dwVersion = _dwVersion;
32397 0 : r.in.isTargetedAtObject = _isTargetedAtObject;
32398 :
32399 : /* Out parameters */
32400 0 : r.out.rpc_status = _rpc_status;
32401 :
32402 : /* Result */
32403 0 : NDR_ZERO_STRUCT(r.out.result);
32404 :
32405 0 : status = dcerpc_clusapi_AddNotifyV2_r(h, mem_ctx, &r);
32406 0 : if (!NT_STATUS_IS_OK(status)) {
32407 0 : return status;
32408 : }
32409 :
32410 : /* Return variables */
32411 0 : *_rpc_status = *r.out.rpc_status;
32412 :
32413 : /* Return result */
32414 0 : *result = r.out.result;
32415 :
32416 0 : return NT_STATUS_OK;
32417 : }
32418 :
32419 : struct dcerpc_clusapi_GetNotifyV2_r_state {
32420 : TALLOC_CTX *out_mem_ctx;
32421 : };
32422 :
32423 : static void dcerpc_clusapi_GetNotifyV2_r_done(struct tevent_req *subreq);
32424 :
32425 0 : struct tevent_req *dcerpc_clusapi_GetNotifyV2_r_send(TALLOC_CTX *mem_ctx,
32426 : struct tevent_context *ev,
32427 : struct dcerpc_binding_handle *h,
32428 : struct clusapi_GetNotifyV2 *r)
32429 : {
32430 : struct tevent_req *req;
32431 : struct dcerpc_clusapi_GetNotifyV2_r_state *state;
32432 : struct tevent_req *subreq;
32433 :
32434 0 : req = tevent_req_create(mem_ctx, &state,
32435 : struct dcerpc_clusapi_GetNotifyV2_r_state);
32436 0 : if (req == NULL) {
32437 0 : return NULL;
32438 : }
32439 :
32440 0 : state->out_mem_ctx = talloc_new(state);
32441 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32442 0 : return tevent_req_post(req, ev);
32443 : }
32444 :
32445 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
32446 : NULL, &ndr_table_clusapi,
32447 0 : NDR_CLUSAPI_GETNOTIFYV2, state->out_mem_ctx, r);
32448 0 : if (tevent_req_nomem(subreq, req)) {
32449 0 : return tevent_req_post(req, ev);
32450 : }
32451 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotifyV2_r_done, req);
32452 :
32453 0 : return req;
32454 : }
32455 :
32456 0 : static void dcerpc_clusapi_GetNotifyV2_r_done(struct tevent_req *subreq)
32457 : {
32458 0 : struct tevent_req *req =
32459 0 : tevent_req_callback_data(subreq,
32460 : struct tevent_req);
32461 : NTSTATUS status;
32462 :
32463 0 : status = dcerpc_binding_handle_call_recv(subreq);
32464 0 : TALLOC_FREE(subreq);
32465 0 : if (tevent_req_nterror(req, status)) {
32466 0 : return;
32467 : }
32468 :
32469 0 : tevent_req_done(req);
32470 : }
32471 :
32472 0 : NTSTATUS dcerpc_clusapi_GetNotifyV2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
32473 : {
32474 0 : struct dcerpc_clusapi_GetNotifyV2_r_state *state =
32475 0 : tevent_req_data(req,
32476 : struct dcerpc_clusapi_GetNotifyV2_r_state);
32477 : NTSTATUS status;
32478 :
32479 0 : if (tevent_req_is_nterror(req, &status)) {
32480 0 : tevent_req_received(req);
32481 0 : return status;
32482 : }
32483 :
32484 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32485 :
32486 0 : tevent_req_received(req);
32487 0 : return NT_STATUS_OK;
32488 : }
32489 :
32490 0 : NTSTATUS dcerpc_clusapi_GetNotifyV2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNotifyV2 *r)
32491 : {
32492 : NTSTATUS status;
32493 :
32494 0 : status = dcerpc_binding_handle_call(h,
32495 : NULL, &ndr_table_clusapi,
32496 : NDR_CLUSAPI_GETNOTIFYV2, mem_ctx, r);
32497 :
32498 0 : return status;
32499 : }
32500 :
32501 : struct dcerpc_clusapi_GetNotifyV2_state {
32502 : struct clusapi_GetNotifyV2 orig;
32503 : struct clusapi_GetNotifyV2 tmp;
32504 : TALLOC_CTX *out_mem_ctx;
32505 : };
32506 :
32507 : static void dcerpc_clusapi_GetNotifyV2_done(struct tevent_req *subreq);
32508 :
32509 0 : struct tevent_req *dcerpc_clusapi_GetNotifyV2_send(TALLOC_CTX *mem_ctx,
32510 : struct tevent_context *ev,
32511 : struct dcerpc_binding_handle *h,
32512 : struct policy_handle _hNotify /* [in] */,
32513 : struct NOTIFICATION_RPC **_Notifications /* [out] [ref,size_is(,*dwNumNotifications)] */,
32514 : uint32_t *_dwNumNotifications /* [out] [ref] */)
32515 : {
32516 : struct tevent_req *req;
32517 : struct dcerpc_clusapi_GetNotifyV2_state *state;
32518 : struct tevent_req *subreq;
32519 :
32520 0 : req = tevent_req_create(mem_ctx, &state,
32521 : struct dcerpc_clusapi_GetNotifyV2_state);
32522 0 : if (req == NULL) {
32523 0 : return NULL;
32524 : }
32525 0 : state->out_mem_ctx = NULL;
32526 :
32527 : /* In parameters */
32528 0 : state->orig.in.hNotify = _hNotify;
32529 :
32530 : /* Out parameters */
32531 0 : state->orig.out.Notifications = _Notifications;
32532 0 : state->orig.out.dwNumNotifications = _dwNumNotifications;
32533 :
32534 : /* Result */
32535 0 : NDR_ZERO_STRUCT(state->orig.out.result);
32536 :
32537 0 : state->out_mem_ctx = talloc_named_const(state, 0,
32538 : "dcerpc_clusapi_GetNotifyV2_out_memory");
32539 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32540 0 : return tevent_req_post(req, ev);
32541 : }
32542 :
32543 : /* make a temporary copy, that we pass to the dispatch function */
32544 0 : state->tmp = state->orig;
32545 :
32546 0 : subreq = dcerpc_clusapi_GetNotifyV2_r_send(state, ev, h, &state->tmp);
32547 0 : if (tevent_req_nomem(subreq, req)) {
32548 0 : return tevent_req_post(req, ev);
32549 : }
32550 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotifyV2_done, req);
32551 0 : return req;
32552 : }
32553 :
32554 0 : static void dcerpc_clusapi_GetNotifyV2_done(struct tevent_req *subreq)
32555 : {
32556 0 : struct tevent_req *req = tevent_req_callback_data(
32557 : subreq, struct tevent_req);
32558 0 : struct dcerpc_clusapi_GetNotifyV2_state *state = tevent_req_data(
32559 : req, struct dcerpc_clusapi_GetNotifyV2_state);
32560 : NTSTATUS status;
32561 : TALLOC_CTX *mem_ctx;
32562 :
32563 0 : if (state->out_mem_ctx) {
32564 0 : mem_ctx = state->out_mem_ctx;
32565 : } else {
32566 0 : mem_ctx = state;
32567 : }
32568 :
32569 0 : status = dcerpc_clusapi_GetNotifyV2_r_recv(subreq, mem_ctx);
32570 0 : TALLOC_FREE(subreq);
32571 0 : if (tevent_req_nterror(req, status)) {
32572 0 : return;
32573 : }
32574 :
32575 : /* Copy out parameters */
32576 0 : *state->orig.out.Notifications = *state->tmp.out.Notifications;
32577 0 : *state->orig.out.dwNumNotifications = *state->tmp.out.dwNumNotifications;
32578 :
32579 : /* Copy result */
32580 0 : state->orig.out.result = state->tmp.out.result;
32581 :
32582 : /* Reset temporary structure */
32583 0 : NDR_ZERO_STRUCT(state->tmp);
32584 :
32585 0 : tevent_req_done(req);
32586 : }
32587 :
32588 0 : NTSTATUS dcerpc_clusapi_GetNotifyV2_recv(struct tevent_req *req,
32589 : TALLOC_CTX *mem_ctx,
32590 : WERROR *result)
32591 : {
32592 0 : struct dcerpc_clusapi_GetNotifyV2_state *state = tevent_req_data(
32593 : req, struct dcerpc_clusapi_GetNotifyV2_state);
32594 : NTSTATUS status;
32595 :
32596 0 : if (tevent_req_is_nterror(req, &status)) {
32597 0 : tevent_req_received(req);
32598 0 : return status;
32599 : }
32600 :
32601 : /* Steal possible out parameters to the callers context */
32602 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32603 :
32604 : /* Return result */
32605 0 : *result = state->orig.out.result;
32606 :
32607 0 : tevent_req_received(req);
32608 0 : return NT_STATUS_OK;
32609 : }
32610 :
32611 0 : NTSTATUS dcerpc_clusapi_GetNotifyV2(struct dcerpc_binding_handle *h,
32612 : TALLOC_CTX *mem_ctx,
32613 : struct policy_handle _hNotify /* [in] */,
32614 : struct NOTIFICATION_RPC **_Notifications /* [out] [ref,size_is(,*dwNumNotifications)] */,
32615 : uint32_t *_dwNumNotifications /* [out] [ref] */,
32616 : WERROR *result)
32617 : {
32618 : struct clusapi_GetNotifyV2 r;
32619 : NTSTATUS status;
32620 :
32621 : /* In parameters */
32622 0 : r.in.hNotify = _hNotify;
32623 :
32624 : /* Out parameters */
32625 0 : r.out.Notifications = _Notifications;
32626 0 : r.out.dwNumNotifications = _dwNumNotifications;
32627 :
32628 : /* Result */
32629 0 : NDR_ZERO_STRUCT(r.out.result);
32630 :
32631 0 : status = dcerpc_clusapi_GetNotifyV2_r(h, mem_ctx, &r);
32632 0 : if (!NT_STATUS_IS_OK(status)) {
32633 0 : return status;
32634 : }
32635 :
32636 : /* Return variables */
32637 0 : *_Notifications = *r.out.Notifications;
32638 0 : *_dwNumNotifications = *r.out.dwNumNotifications;
32639 :
32640 : /* Return result */
32641 0 : *result = r.out.result;
32642 :
32643 0 : return NT_STATUS_OK;
32644 : }
32645 :
32646 : struct dcerpc_clusapi_QueryAllValues_r_state {
32647 : TALLOC_CTX *out_mem_ctx;
32648 : };
32649 :
32650 : static void dcerpc_clusapi_QueryAllValues_r_done(struct tevent_req *subreq);
32651 :
32652 0 : struct tevent_req *dcerpc_clusapi_QueryAllValues_r_send(TALLOC_CTX *mem_ctx,
32653 : struct tevent_context *ev,
32654 : struct dcerpc_binding_handle *h,
32655 : struct clusapi_QueryAllValues *r)
32656 : {
32657 : struct tevent_req *req;
32658 : struct dcerpc_clusapi_QueryAllValues_r_state *state;
32659 : struct tevent_req *subreq;
32660 :
32661 0 : req = tevent_req_create(mem_ctx, &state,
32662 : struct dcerpc_clusapi_QueryAllValues_r_state);
32663 0 : if (req == NULL) {
32664 0 : return NULL;
32665 : }
32666 :
32667 0 : state->out_mem_ctx = talloc_new(state);
32668 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32669 0 : return tevent_req_post(req, ev);
32670 : }
32671 :
32672 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
32673 : NULL, &ndr_table_clusapi,
32674 0 : NDR_CLUSAPI_QUERYALLVALUES, state->out_mem_ctx, r);
32675 0 : if (tevent_req_nomem(subreq, req)) {
32676 0 : return tevent_req_post(req, ev);
32677 : }
32678 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryAllValues_r_done, req);
32679 :
32680 0 : return req;
32681 : }
32682 :
32683 0 : static void dcerpc_clusapi_QueryAllValues_r_done(struct tevent_req *subreq)
32684 : {
32685 0 : struct tevent_req *req =
32686 0 : tevent_req_callback_data(subreq,
32687 : struct tevent_req);
32688 : NTSTATUS status;
32689 :
32690 0 : status = dcerpc_binding_handle_call_recv(subreq);
32691 0 : TALLOC_FREE(subreq);
32692 0 : if (tevent_req_nterror(req, status)) {
32693 0 : return;
32694 : }
32695 :
32696 0 : tevent_req_done(req);
32697 : }
32698 :
32699 0 : NTSTATUS dcerpc_clusapi_QueryAllValues_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
32700 : {
32701 0 : struct dcerpc_clusapi_QueryAllValues_r_state *state =
32702 0 : tevent_req_data(req,
32703 : struct dcerpc_clusapi_QueryAllValues_r_state);
32704 : NTSTATUS status;
32705 :
32706 0 : if (tevent_req_is_nterror(req, &status)) {
32707 0 : tevent_req_received(req);
32708 0 : return status;
32709 : }
32710 :
32711 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32712 :
32713 0 : tevent_req_received(req);
32714 0 : return NT_STATUS_OK;
32715 : }
32716 :
32717 0 : NTSTATUS dcerpc_clusapi_QueryAllValues_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_QueryAllValues *r)
32718 : {
32719 : NTSTATUS status;
32720 :
32721 0 : status = dcerpc_binding_handle_call(h,
32722 : NULL, &ndr_table_clusapi,
32723 : NDR_CLUSAPI_QUERYALLVALUES, mem_ctx, r);
32724 :
32725 0 : return status;
32726 : }
32727 :
32728 : struct dcerpc_clusapi_QueryAllValues_state {
32729 : struct clusapi_QueryAllValues orig;
32730 : struct clusapi_QueryAllValues tmp;
32731 : TALLOC_CTX *out_mem_ctx;
32732 : };
32733 :
32734 : static void dcerpc_clusapi_QueryAllValues_done(struct tevent_req *subreq);
32735 :
32736 0 : struct tevent_req *dcerpc_clusapi_QueryAllValues_send(TALLOC_CTX *mem_ctx,
32737 : struct tevent_context *ev,
32738 : struct dcerpc_binding_handle *h,
32739 : struct policy_handle _hKey /* [in] */,
32740 : uint32_t *_pcbData /* [out] [ref] */,
32741 : uint8_t **_ppData /* [out] [ref,size_is(1,*pcbData)] */,
32742 : WERROR *_rpc_status /* [out] [ref] */)
32743 : {
32744 : struct tevent_req *req;
32745 : struct dcerpc_clusapi_QueryAllValues_state *state;
32746 : struct tevent_req *subreq;
32747 :
32748 0 : req = tevent_req_create(mem_ctx, &state,
32749 : struct dcerpc_clusapi_QueryAllValues_state);
32750 0 : if (req == NULL) {
32751 0 : return NULL;
32752 : }
32753 0 : state->out_mem_ctx = NULL;
32754 :
32755 : /* In parameters */
32756 0 : state->orig.in.hKey = _hKey;
32757 :
32758 : /* Out parameters */
32759 0 : state->orig.out.pcbData = _pcbData;
32760 0 : state->orig.out.ppData = _ppData;
32761 0 : state->orig.out.rpc_status = _rpc_status;
32762 :
32763 : /* Result */
32764 0 : NDR_ZERO_STRUCT(state->orig.out.result);
32765 :
32766 0 : state->out_mem_ctx = talloc_named_const(state, 0,
32767 : "dcerpc_clusapi_QueryAllValues_out_memory");
32768 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32769 0 : return tevent_req_post(req, ev);
32770 : }
32771 :
32772 : /* make a temporary copy, that we pass to the dispatch function */
32773 0 : state->tmp = state->orig;
32774 :
32775 0 : subreq = dcerpc_clusapi_QueryAllValues_r_send(state, ev, h, &state->tmp);
32776 0 : if (tevent_req_nomem(subreq, req)) {
32777 0 : return tevent_req_post(req, ev);
32778 : }
32779 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_QueryAllValues_done, req);
32780 0 : return req;
32781 : }
32782 :
32783 0 : static void dcerpc_clusapi_QueryAllValues_done(struct tevent_req *subreq)
32784 : {
32785 0 : struct tevent_req *req = tevent_req_callback_data(
32786 : subreq, struct tevent_req);
32787 0 : struct dcerpc_clusapi_QueryAllValues_state *state = tevent_req_data(
32788 : req, struct dcerpc_clusapi_QueryAllValues_state);
32789 : NTSTATUS status;
32790 : TALLOC_CTX *mem_ctx;
32791 :
32792 0 : if (state->out_mem_ctx) {
32793 0 : mem_ctx = state->out_mem_ctx;
32794 : } else {
32795 0 : mem_ctx = state;
32796 : }
32797 :
32798 0 : status = dcerpc_clusapi_QueryAllValues_r_recv(subreq, mem_ctx);
32799 0 : TALLOC_FREE(subreq);
32800 0 : if (tevent_req_nterror(req, status)) {
32801 0 : return;
32802 : }
32803 :
32804 : /* Copy out parameters */
32805 0 : *state->orig.out.pcbData = *state->tmp.out.pcbData;
32806 : {
32807 : size_t _copy_len_ppData;
32808 0 : _copy_len_ppData = 1;
32809 0 : if (state->orig.out.ppData != state->tmp.out.ppData) {
32810 0 : memcpy(state->orig.out.ppData, state->tmp.out.ppData, _copy_len_ppData * sizeof(*state->orig.out.ppData));
32811 : }
32812 : }
32813 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
32814 :
32815 : /* Copy result */
32816 0 : state->orig.out.result = state->tmp.out.result;
32817 :
32818 : /* Reset temporary structure */
32819 0 : NDR_ZERO_STRUCT(state->tmp);
32820 :
32821 0 : tevent_req_done(req);
32822 : }
32823 :
32824 0 : NTSTATUS dcerpc_clusapi_QueryAllValues_recv(struct tevent_req *req,
32825 : TALLOC_CTX *mem_ctx,
32826 : WERROR *result)
32827 : {
32828 0 : struct dcerpc_clusapi_QueryAllValues_state *state = tevent_req_data(
32829 : req, struct dcerpc_clusapi_QueryAllValues_state);
32830 : NTSTATUS status;
32831 :
32832 0 : if (tevent_req_is_nterror(req, &status)) {
32833 0 : tevent_req_received(req);
32834 0 : return status;
32835 : }
32836 :
32837 : /* Steal possible out parameters to the callers context */
32838 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32839 :
32840 : /* Return result */
32841 0 : *result = state->orig.out.result;
32842 :
32843 0 : tevent_req_received(req);
32844 0 : return NT_STATUS_OK;
32845 : }
32846 :
32847 0 : NTSTATUS dcerpc_clusapi_QueryAllValues(struct dcerpc_binding_handle *h,
32848 : TALLOC_CTX *mem_ctx,
32849 : struct policy_handle _hKey /* [in] */,
32850 : uint32_t *_pcbData /* [out] [ref] */,
32851 : uint8_t **_ppData /* [out] [ref,size_is(1,*pcbData)] */,
32852 : WERROR *_rpc_status /* [out] [ref] */,
32853 : WERROR *result)
32854 : {
32855 : struct clusapi_QueryAllValues r;
32856 : NTSTATUS status;
32857 :
32858 : /* In parameters */
32859 0 : r.in.hKey = _hKey;
32860 :
32861 : /* Out parameters */
32862 0 : r.out.pcbData = _pcbData;
32863 0 : r.out.ppData = _ppData;
32864 0 : r.out.rpc_status = _rpc_status;
32865 :
32866 : /* Result */
32867 0 : NDR_ZERO_STRUCT(r.out.result);
32868 :
32869 0 : status = dcerpc_clusapi_QueryAllValues_r(h, mem_ctx, &r);
32870 0 : if (!NT_STATUS_IS_OK(status)) {
32871 0 : return status;
32872 : }
32873 :
32874 : /* Return variables */
32875 0 : *_pcbData = *r.out.pcbData;
32876 : {
32877 : size_t _copy_len_ppData;
32878 0 : _copy_len_ppData = 1;
32879 0 : if (_ppData != r.out.ppData) {
32880 0 : memcpy(_ppData, r.out.ppData, _copy_len_ppData * sizeof(*_ppData));
32881 : }
32882 : }
32883 0 : *_rpc_status = *r.out.rpc_status;
32884 :
32885 : /* Return result */
32886 0 : *result = r.out.result;
32887 :
32888 0 : return NT_STATUS_OK;
32889 : }
32890 :
32891 : struct dcerpc_clusapi_StmFindDisk_r_state {
32892 : TALLOC_CTX *out_mem_ctx;
32893 : };
32894 :
32895 : static void dcerpc_clusapi_StmFindDisk_r_done(struct tevent_req *subreq);
32896 :
32897 0 : struct tevent_req *dcerpc_clusapi_StmFindDisk_r_send(TALLOC_CTX *mem_ctx,
32898 : struct tevent_context *ev,
32899 : struct dcerpc_binding_handle *h,
32900 : struct clusapi_StmFindDisk *r)
32901 : {
32902 : struct tevent_req *req;
32903 : struct dcerpc_clusapi_StmFindDisk_r_state *state;
32904 : struct tevent_req *subreq;
32905 :
32906 0 : req = tevent_req_create(mem_ctx, &state,
32907 : struct dcerpc_clusapi_StmFindDisk_r_state);
32908 0 : if (req == NULL) {
32909 0 : return NULL;
32910 : }
32911 :
32912 0 : state->out_mem_ctx = talloc_new(state);
32913 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
32914 0 : return tevent_req_post(req, ev);
32915 : }
32916 :
32917 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
32918 : NULL, &ndr_table_clusapi,
32919 0 : NDR_CLUSAPI_STMFINDDISK, state->out_mem_ctx, r);
32920 0 : if (tevent_req_nomem(subreq, req)) {
32921 0 : return tevent_req_post(req, ev);
32922 : }
32923 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_StmFindDisk_r_done, req);
32924 :
32925 0 : return req;
32926 : }
32927 :
32928 0 : static void dcerpc_clusapi_StmFindDisk_r_done(struct tevent_req *subreq)
32929 : {
32930 0 : struct tevent_req *req =
32931 0 : tevent_req_callback_data(subreq,
32932 : struct tevent_req);
32933 : NTSTATUS status;
32934 :
32935 0 : status = dcerpc_binding_handle_call_recv(subreq);
32936 0 : TALLOC_FREE(subreq);
32937 0 : if (tevent_req_nterror(req, status)) {
32938 0 : return;
32939 : }
32940 :
32941 0 : tevent_req_done(req);
32942 : }
32943 :
32944 0 : NTSTATUS dcerpc_clusapi_StmFindDisk_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
32945 : {
32946 0 : struct dcerpc_clusapi_StmFindDisk_r_state *state =
32947 0 : tevent_req_data(req,
32948 : struct dcerpc_clusapi_StmFindDisk_r_state);
32949 : NTSTATUS status;
32950 :
32951 0 : if (tevent_req_is_nterror(req, &status)) {
32952 0 : tevent_req_received(req);
32953 0 : return status;
32954 : }
32955 :
32956 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
32957 :
32958 0 : tevent_req_received(req);
32959 0 : return NT_STATUS_OK;
32960 : }
32961 :
32962 0 : NTSTATUS dcerpc_clusapi_StmFindDisk_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_StmFindDisk *r)
32963 : {
32964 : NTSTATUS status;
32965 :
32966 0 : status = dcerpc_binding_handle_call(h,
32967 : NULL, &ndr_table_clusapi,
32968 : NDR_CLUSAPI_STMFINDDISK, mem_ctx, r);
32969 :
32970 0 : return status;
32971 : }
32972 :
32973 : struct dcerpc_clusapi_StmFindDisk_state {
32974 : struct clusapi_StmFindDisk orig;
32975 : struct clusapi_StmFindDisk tmp;
32976 : TALLOC_CTX *out_mem_ctx;
32977 : };
32978 :
32979 : static void dcerpc_clusapi_StmFindDisk_done(struct tevent_req *subreq);
32980 :
32981 0 : struct tevent_req *dcerpc_clusapi_StmFindDisk_send(TALLOC_CTX *mem_ctx,
32982 : struct tevent_context *ev,
32983 : struct dcerpc_binding_handle *h,
32984 : struct policy_handle _hCluster /* [in] */,
32985 : uint32_t _dwFlags /* [in] */,
32986 : struct CLUSTER_DISKID *_pDiskId /* [in,out] [unique] */,
32987 : uint8_t *_pUniqueId /* [in] [size_is(uniqueIdSize),unique] */,
32988 : uint32_t _uniqueIdSize /* [in] */,
32989 : const char **_ppszDeviceName /* [out] [charset(UTF16),ref] */,
32990 : WERROR *_rpc_status /* [out] [ref] */)
32991 : {
32992 : struct tevent_req *req;
32993 : struct dcerpc_clusapi_StmFindDisk_state *state;
32994 : struct tevent_req *subreq;
32995 :
32996 0 : req = tevent_req_create(mem_ctx, &state,
32997 : struct dcerpc_clusapi_StmFindDisk_state);
32998 0 : if (req == NULL) {
32999 0 : return NULL;
33000 : }
33001 0 : state->out_mem_ctx = NULL;
33002 :
33003 : /* In parameters */
33004 0 : state->orig.in.hCluster = _hCluster;
33005 0 : state->orig.in.dwFlags = _dwFlags;
33006 0 : state->orig.in.pDiskId = _pDiskId;
33007 0 : state->orig.in.pUniqueId = _pUniqueId;
33008 0 : state->orig.in.uniqueIdSize = _uniqueIdSize;
33009 :
33010 : /* Out parameters */
33011 0 : state->orig.out.pDiskId = _pDiskId;
33012 0 : state->orig.out.ppszDeviceName = _ppszDeviceName;
33013 0 : state->orig.out.rpc_status = _rpc_status;
33014 :
33015 : /* Result */
33016 0 : NDR_ZERO_STRUCT(state->orig.out.result);
33017 :
33018 0 : state->out_mem_ctx = talloc_named_const(state, 0,
33019 : "dcerpc_clusapi_StmFindDisk_out_memory");
33020 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33021 0 : return tevent_req_post(req, ev);
33022 : }
33023 :
33024 : /* make a temporary copy, that we pass to the dispatch function */
33025 0 : state->tmp = state->orig;
33026 :
33027 0 : subreq = dcerpc_clusapi_StmFindDisk_r_send(state, ev, h, &state->tmp);
33028 0 : if (tevent_req_nomem(subreq, req)) {
33029 0 : return tevent_req_post(req, ev);
33030 : }
33031 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_StmFindDisk_done, req);
33032 0 : return req;
33033 : }
33034 :
33035 0 : static void dcerpc_clusapi_StmFindDisk_done(struct tevent_req *subreq)
33036 : {
33037 0 : struct tevent_req *req = tevent_req_callback_data(
33038 : subreq, struct tevent_req);
33039 0 : struct dcerpc_clusapi_StmFindDisk_state *state = tevent_req_data(
33040 : req, struct dcerpc_clusapi_StmFindDisk_state);
33041 : NTSTATUS status;
33042 : TALLOC_CTX *mem_ctx;
33043 :
33044 0 : if (state->out_mem_ctx) {
33045 0 : mem_ctx = state->out_mem_ctx;
33046 : } else {
33047 0 : mem_ctx = state;
33048 : }
33049 :
33050 0 : status = dcerpc_clusapi_StmFindDisk_r_recv(subreq, mem_ctx);
33051 0 : TALLOC_FREE(subreq);
33052 0 : if (tevent_req_nterror(req, status)) {
33053 0 : return;
33054 : }
33055 :
33056 : /* Copy out parameters */
33057 0 : if (state->orig.out.pDiskId && state->tmp.out.pDiskId) {
33058 0 : *state->orig.out.pDiskId = *state->tmp.out.pDiskId;
33059 : }
33060 0 : *state->orig.out.ppszDeviceName = *state->tmp.out.ppszDeviceName;
33061 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
33062 :
33063 : /* Copy result */
33064 0 : state->orig.out.result = state->tmp.out.result;
33065 :
33066 : /* Reset temporary structure */
33067 0 : NDR_ZERO_STRUCT(state->tmp);
33068 :
33069 0 : tevent_req_done(req);
33070 : }
33071 :
33072 0 : NTSTATUS dcerpc_clusapi_StmFindDisk_recv(struct tevent_req *req,
33073 : TALLOC_CTX *mem_ctx,
33074 : WERROR *result)
33075 : {
33076 0 : struct dcerpc_clusapi_StmFindDisk_state *state = tevent_req_data(
33077 : req, struct dcerpc_clusapi_StmFindDisk_state);
33078 : NTSTATUS status;
33079 :
33080 0 : if (tevent_req_is_nterror(req, &status)) {
33081 0 : tevent_req_received(req);
33082 0 : return status;
33083 : }
33084 :
33085 : /* Steal possible out parameters to the callers context */
33086 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33087 :
33088 : /* Return result */
33089 0 : *result = state->orig.out.result;
33090 :
33091 0 : tevent_req_received(req);
33092 0 : return NT_STATUS_OK;
33093 : }
33094 :
33095 0 : NTSTATUS dcerpc_clusapi_StmFindDisk(struct dcerpc_binding_handle *h,
33096 : TALLOC_CTX *mem_ctx,
33097 : struct policy_handle _hCluster /* [in] */,
33098 : uint32_t _dwFlags /* [in] */,
33099 : struct CLUSTER_DISKID *_pDiskId /* [in,out] [unique] */,
33100 : uint8_t *_pUniqueId /* [in] [size_is(uniqueIdSize),unique] */,
33101 : uint32_t _uniqueIdSize /* [in] */,
33102 : const char **_ppszDeviceName /* [out] [charset(UTF16),ref] */,
33103 : WERROR *_rpc_status /* [out] [ref] */,
33104 : WERROR *result)
33105 : {
33106 : struct clusapi_StmFindDisk r;
33107 : NTSTATUS status;
33108 :
33109 : /* In parameters */
33110 0 : r.in.hCluster = _hCluster;
33111 0 : r.in.dwFlags = _dwFlags;
33112 0 : r.in.pDiskId = _pDiskId;
33113 0 : r.in.pUniqueId = _pUniqueId;
33114 0 : r.in.uniqueIdSize = _uniqueIdSize;
33115 :
33116 : /* Out parameters */
33117 0 : r.out.pDiskId = _pDiskId;
33118 0 : r.out.ppszDeviceName = _ppszDeviceName;
33119 0 : r.out.rpc_status = _rpc_status;
33120 :
33121 : /* Result */
33122 0 : NDR_ZERO_STRUCT(r.out.result);
33123 :
33124 0 : status = dcerpc_clusapi_StmFindDisk_r(h, mem_ctx, &r);
33125 0 : if (!NT_STATUS_IS_OK(status)) {
33126 0 : return status;
33127 : }
33128 :
33129 : /* Return variables */
33130 0 : if (_pDiskId && r.out.pDiskId) {
33131 0 : *_pDiskId = *r.out.pDiskId;
33132 : }
33133 0 : *_ppszDeviceName = *r.out.ppszDeviceName;
33134 0 : *_rpc_status = *r.out.rpc_status;
33135 :
33136 : /* Return result */
33137 0 : *result = r.out.result;
33138 :
33139 0 : return NT_STATUS_OK;
33140 : }
33141 :
33142 : struct dcerpc_clusapi_ClusterMrr_r_state {
33143 : TALLOC_CTX *out_mem_ctx;
33144 : };
33145 :
33146 : static void dcerpc_clusapi_ClusterMrr_r_done(struct tevent_req *subreq);
33147 :
33148 0 : struct tevent_req *dcerpc_clusapi_ClusterMrr_r_send(TALLOC_CTX *mem_ctx,
33149 : struct tevent_context *ev,
33150 : struct dcerpc_binding_handle *h,
33151 : struct clusapi_ClusterMrr *r)
33152 : {
33153 : struct tevent_req *req;
33154 : struct dcerpc_clusapi_ClusterMrr_r_state *state;
33155 : struct tevent_req *subreq;
33156 :
33157 0 : req = tevent_req_create(mem_ctx, &state,
33158 : struct dcerpc_clusapi_ClusterMrr_r_state);
33159 0 : if (req == NULL) {
33160 0 : return NULL;
33161 : }
33162 :
33163 0 : state->out_mem_ctx = talloc_new(state);
33164 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33165 0 : return tevent_req_post(req, ev);
33166 : }
33167 :
33168 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
33169 : NULL, &ndr_table_clusapi,
33170 0 : NDR_CLUSAPI_CLUSTERMRR, state->out_mem_ctx, r);
33171 0 : if (tevent_req_nomem(subreq, req)) {
33172 0 : return tevent_req_post(req, ev);
33173 : }
33174 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ClusterMrr_r_done, req);
33175 :
33176 0 : return req;
33177 : }
33178 :
33179 0 : static void dcerpc_clusapi_ClusterMrr_r_done(struct tevent_req *subreq)
33180 : {
33181 0 : struct tevent_req *req =
33182 0 : tevent_req_callback_data(subreq,
33183 : struct tevent_req);
33184 : NTSTATUS status;
33185 :
33186 0 : status = dcerpc_binding_handle_call_recv(subreq);
33187 0 : TALLOC_FREE(subreq);
33188 0 : if (tevent_req_nterror(req, status)) {
33189 0 : return;
33190 : }
33191 :
33192 0 : tevent_req_done(req);
33193 : }
33194 :
33195 0 : NTSTATUS dcerpc_clusapi_ClusterMrr_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
33196 : {
33197 0 : struct dcerpc_clusapi_ClusterMrr_r_state *state =
33198 0 : tevent_req_data(req,
33199 : struct dcerpc_clusapi_ClusterMrr_r_state);
33200 : NTSTATUS status;
33201 :
33202 0 : if (tevent_req_is_nterror(req, &status)) {
33203 0 : tevent_req_received(req);
33204 0 : return status;
33205 : }
33206 :
33207 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33208 :
33209 0 : tevent_req_received(req);
33210 0 : return NT_STATUS_OK;
33211 : }
33212 :
33213 0 : NTSTATUS dcerpc_clusapi_ClusterMrr_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ClusterMrr *r)
33214 : {
33215 : NTSTATUS status;
33216 :
33217 0 : status = dcerpc_binding_handle_call(h,
33218 : NULL, &ndr_table_clusapi,
33219 : NDR_CLUSAPI_CLUSTERMRR, mem_ctx, r);
33220 :
33221 0 : return status;
33222 : }
33223 :
33224 : struct dcerpc_clusapi_ClusterMrr_state {
33225 : struct clusapi_ClusterMrr orig;
33226 : struct clusapi_ClusterMrr tmp;
33227 : TALLOC_CTX *out_mem_ctx;
33228 : };
33229 :
33230 : static void dcerpc_clusapi_ClusterMrr_done(struct tevent_req *subreq);
33231 :
33232 0 : struct tevent_req *dcerpc_clusapi_ClusterMrr_send(TALLOC_CTX *mem_ctx,
33233 : struct tevent_context *ev,
33234 : struct dcerpc_binding_handle *h,
33235 : struct policy_handle _hCluster /* [in] */,
33236 : uint8_t _fExcludeSelf /* [in] */,
33237 : uint64_t _nodeSet /* [in] */,
33238 : uint32_t _dwTimeout /* [in] */,
33239 : uint32_t _dwComponent /* [in] */,
33240 : uint32_t _dwControlCode /* [in] */,
33241 : uint32_t _inSize /* [in] */,
33242 : uint8_t *_pInData /* [in] [size_is(inSize),unique] */,
33243 : struct CLUSTER_MRR_RESPONSE **_ppInfo /* [out] [ref,size_is(1,1)] */,
33244 : WERROR *_rpc_status /* [out] [ref] */)
33245 : {
33246 : struct tevent_req *req;
33247 : struct dcerpc_clusapi_ClusterMrr_state *state;
33248 : struct tevent_req *subreq;
33249 :
33250 0 : req = tevent_req_create(mem_ctx, &state,
33251 : struct dcerpc_clusapi_ClusterMrr_state);
33252 0 : if (req == NULL) {
33253 0 : return NULL;
33254 : }
33255 0 : state->out_mem_ctx = NULL;
33256 :
33257 : /* In parameters */
33258 0 : state->orig.in.hCluster = _hCluster;
33259 0 : state->orig.in.fExcludeSelf = _fExcludeSelf;
33260 0 : state->orig.in.nodeSet = _nodeSet;
33261 0 : state->orig.in.dwTimeout = _dwTimeout;
33262 0 : state->orig.in.dwComponent = _dwComponent;
33263 0 : state->orig.in.dwControlCode = _dwControlCode;
33264 0 : state->orig.in.inSize = _inSize;
33265 0 : state->orig.in.pInData = _pInData;
33266 :
33267 : /* Out parameters */
33268 0 : state->orig.out.ppInfo = _ppInfo;
33269 0 : state->orig.out.rpc_status = _rpc_status;
33270 :
33271 : /* Result */
33272 0 : NDR_ZERO_STRUCT(state->orig.out.result);
33273 :
33274 0 : state->out_mem_ctx = talloc_named_const(state, 0,
33275 : "dcerpc_clusapi_ClusterMrr_out_memory");
33276 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33277 0 : return tevent_req_post(req, ev);
33278 : }
33279 :
33280 : /* make a temporary copy, that we pass to the dispatch function */
33281 0 : state->tmp = state->orig;
33282 :
33283 0 : subreq = dcerpc_clusapi_ClusterMrr_r_send(state, ev, h, &state->tmp);
33284 0 : if (tevent_req_nomem(subreq, req)) {
33285 0 : return tevent_req_post(req, ev);
33286 : }
33287 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ClusterMrr_done, req);
33288 0 : return req;
33289 : }
33290 :
33291 0 : static void dcerpc_clusapi_ClusterMrr_done(struct tevent_req *subreq)
33292 : {
33293 0 : struct tevent_req *req = tevent_req_callback_data(
33294 : subreq, struct tevent_req);
33295 0 : struct dcerpc_clusapi_ClusterMrr_state *state = tevent_req_data(
33296 : req, struct dcerpc_clusapi_ClusterMrr_state);
33297 : NTSTATUS status;
33298 : TALLOC_CTX *mem_ctx;
33299 :
33300 0 : if (state->out_mem_ctx) {
33301 0 : mem_ctx = state->out_mem_ctx;
33302 : } else {
33303 0 : mem_ctx = state;
33304 : }
33305 :
33306 0 : status = dcerpc_clusapi_ClusterMrr_r_recv(subreq, mem_ctx);
33307 0 : TALLOC_FREE(subreq);
33308 0 : if (tevent_req_nterror(req, status)) {
33309 0 : return;
33310 : }
33311 :
33312 : /* Copy out parameters */
33313 : {
33314 : size_t _copy_len_ppInfo;
33315 0 : _copy_len_ppInfo = 1;
33316 0 : if (state->orig.out.ppInfo != state->tmp.out.ppInfo) {
33317 0 : memcpy(state->orig.out.ppInfo, state->tmp.out.ppInfo, _copy_len_ppInfo * sizeof(*state->orig.out.ppInfo));
33318 : }
33319 : }
33320 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
33321 :
33322 : /* Copy result */
33323 0 : state->orig.out.result = state->tmp.out.result;
33324 :
33325 : /* Reset temporary structure */
33326 0 : NDR_ZERO_STRUCT(state->tmp);
33327 :
33328 0 : tevent_req_done(req);
33329 : }
33330 :
33331 0 : NTSTATUS dcerpc_clusapi_ClusterMrr_recv(struct tevent_req *req,
33332 : TALLOC_CTX *mem_ctx,
33333 : WERROR *result)
33334 : {
33335 0 : struct dcerpc_clusapi_ClusterMrr_state *state = tevent_req_data(
33336 : req, struct dcerpc_clusapi_ClusterMrr_state);
33337 : NTSTATUS status;
33338 :
33339 0 : if (tevent_req_is_nterror(req, &status)) {
33340 0 : tevent_req_received(req);
33341 0 : return status;
33342 : }
33343 :
33344 : /* Steal possible out parameters to the callers context */
33345 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33346 :
33347 : /* Return result */
33348 0 : *result = state->orig.out.result;
33349 :
33350 0 : tevent_req_received(req);
33351 0 : return NT_STATUS_OK;
33352 : }
33353 :
33354 0 : NTSTATUS dcerpc_clusapi_ClusterMrr(struct dcerpc_binding_handle *h,
33355 : TALLOC_CTX *mem_ctx,
33356 : struct policy_handle _hCluster /* [in] */,
33357 : uint8_t _fExcludeSelf /* [in] */,
33358 : uint64_t _nodeSet /* [in] */,
33359 : uint32_t _dwTimeout /* [in] */,
33360 : uint32_t _dwComponent /* [in] */,
33361 : uint32_t _dwControlCode /* [in] */,
33362 : uint32_t _inSize /* [in] */,
33363 : uint8_t *_pInData /* [in] [size_is(inSize),unique] */,
33364 : struct CLUSTER_MRR_RESPONSE **_ppInfo /* [out] [ref,size_is(1,1)] */,
33365 : WERROR *_rpc_status /* [out] [ref] */,
33366 : WERROR *result)
33367 : {
33368 : struct clusapi_ClusterMrr r;
33369 : NTSTATUS status;
33370 :
33371 : /* In parameters */
33372 0 : r.in.hCluster = _hCluster;
33373 0 : r.in.fExcludeSelf = _fExcludeSelf;
33374 0 : r.in.nodeSet = _nodeSet;
33375 0 : r.in.dwTimeout = _dwTimeout;
33376 0 : r.in.dwComponent = _dwComponent;
33377 0 : r.in.dwControlCode = _dwControlCode;
33378 0 : r.in.inSize = _inSize;
33379 0 : r.in.pInData = _pInData;
33380 :
33381 : /* Out parameters */
33382 0 : r.out.ppInfo = _ppInfo;
33383 0 : r.out.rpc_status = _rpc_status;
33384 :
33385 : /* Result */
33386 0 : NDR_ZERO_STRUCT(r.out.result);
33387 :
33388 0 : status = dcerpc_clusapi_ClusterMrr_r(h, mem_ctx, &r);
33389 0 : if (!NT_STATUS_IS_OK(status)) {
33390 0 : return status;
33391 : }
33392 :
33393 : /* Return variables */
33394 : {
33395 : size_t _copy_len_ppInfo;
33396 0 : _copy_len_ppInfo = 1;
33397 0 : if (_ppInfo != r.out.ppInfo) {
33398 0 : memcpy(_ppInfo, r.out.ppInfo, _copy_len_ppInfo * sizeof(*_ppInfo));
33399 : }
33400 : }
33401 0 : *_rpc_status = *r.out.rpc_status;
33402 :
33403 : /* Return result */
33404 0 : *result = r.out.result;
33405 :
33406 0 : return NT_STATUS_OK;
33407 : }
33408 :
33409 : struct dcerpc_clusapi_CreateGroupEnum_r_state {
33410 : TALLOC_CTX *out_mem_ctx;
33411 : };
33412 :
33413 : static void dcerpc_clusapi_CreateGroupEnum_r_done(struct tevent_req *subreq);
33414 :
33415 0 : struct tevent_req *dcerpc_clusapi_CreateGroupEnum_r_send(TALLOC_CTX *mem_ctx,
33416 : struct tevent_context *ev,
33417 : struct dcerpc_binding_handle *h,
33418 : struct clusapi_CreateGroupEnum *r)
33419 : {
33420 : struct tevent_req *req;
33421 : struct dcerpc_clusapi_CreateGroupEnum_r_state *state;
33422 : struct tevent_req *subreq;
33423 :
33424 0 : req = tevent_req_create(mem_ctx, &state,
33425 : struct dcerpc_clusapi_CreateGroupEnum_r_state);
33426 0 : if (req == NULL) {
33427 0 : return NULL;
33428 : }
33429 :
33430 0 : state->out_mem_ctx = talloc_new(state);
33431 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33432 0 : return tevent_req_post(req, ev);
33433 : }
33434 :
33435 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
33436 : NULL, &ndr_table_clusapi,
33437 0 : NDR_CLUSAPI_CREATEGROUPENUM, state->out_mem_ctx, r);
33438 0 : if (tevent_req_nomem(subreq, req)) {
33439 0 : return tevent_req_post(req, ev);
33440 : }
33441 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupEnum_r_done, req);
33442 :
33443 0 : return req;
33444 : }
33445 :
33446 0 : static void dcerpc_clusapi_CreateGroupEnum_r_done(struct tevent_req *subreq)
33447 : {
33448 0 : struct tevent_req *req =
33449 0 : tevent_req_callback_data(subreq,
33450 : struct tevent_req);
33451 : NTSTATUS status;
33452 :
33453 0 : status = dcerpc_binding_handle_call_recv(subreq);
33454 0 : TALLOC_FREE(subreq);
33455 0 : if (tevent_req_nterror(req, status)) {
33456 0 : return;
33457 : }
33458 :
33459 0 : tevent_req_done(req);
33460 : }
33461 :
33462 0 : NTSTATUS dcerpc_clusapi_CreateGroupEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
33463 : {
33464 0 : struct dcerpc_clusapi_CreateGroupEnum_r_state *state =
33465 0 : tevent_req_data(req,
33466 : struct dcerpc_clusapi_CreateGroupEnum_r_state);
33467 : NTSTATUS status;
33468 :
33469 0 : if (tevent_req_is_nterror(req, &status)) {
33470 0 : tevent_req_received(req);
33471 0 : return status;
33472 : }
33473 :
33474 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33475 :
33476 0 : tevent_req_received(req);
33477 0 : return NT_STATUS_OK;
33478 : }
33479 :
33480 0 : NTSTATUS dcerpc_clusapi_CreateGroupEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroupEnum *r)
33481 : {
33482 : NTSTATUS status;
33483 :
33484 0 : status = dcerpc_binding_handle_call(h,
33485 : NULL, &ndr_table_clusapi,
33486 : NDR_CLUSAPI_CREATEGROUPENUM, mem_ctx, r);
33487 :
33488 0 : return status;
33489 : }
33490 :
33491 : struct dcerpc_clusapi_CreateGroupEnum_state {
33492 : struct clusapi_CreateGroupEnum orig;
33493 : struct clusapi_CreateGroupEnum tmp;
33494 : TALLOC_CTX *out_mem_ctx;
33495 : };
33496 :
33497 : static void dcerpc_clusapi_CreateGroupEnum_done(struct tevent_req *subreq);
33498 :
33499 0 : struct tevent_req *dcerpc_clusapi_CreateGroupEnum_send(TALLOC_CTX *mem_ctx,
33500 : struct tevent_context *ev,
33501 : struct dcerpc_binding_handle *h,
33502 : struct policy_handle _hCluster /* [in] */,
33503 : uint8_t *_pProperties /* [in] [size_is(cbProperties),unique] */,
33504 : uint32_t _cbProperties /* [in] */,
33505 : uint8_t *_pRoProperties /* [in] [size_is(cbRoProperties),unique] */,
33506 : uint32_t _cbRoProperties /* [in] */,
33507 : struct GROUP_ENUM_LIST **_ppResultList /* [out] [ref] */,
33508 : WERROR *_rpc_status /* [out] [ref] */)
33509 : {
33510 : struct tevent_req *req;
33511 : struct dcerpc_clusapi_CreateGroupEnum_state *state;
33512 : struct tevent_req *subreq;
33513 :
33514 0 : req = tevent_req_create(mem_ctx, &state,
33515 : struct dcerpc_clusapi_CreateGroupEnum_state);
33516 0 : if (req == NULL) {
33517 0 : return NULL;
33518 : }
33519 0 : state->out_mem_ctx = NULL;
33520 :
33521 : /* In parameters */
33522 0 : state->orig.in.hCluster = _hCluster;
33523 0 : state->orig.in.pProperties = _pProperties;
33524 0 : state->orig.in.cbProperties = _cbProperties;
33525 0 : state->orig.in.pRoProperties = _pRoProperties;
33526 0 : state->orig.in.cbRoProperties = _cbRoProperties;
33527 :
33528 : /* Out parameters */
33529 0 : state->orig.out.ppResultList = _ppResultList;
33530 0 : state->orig.out.rpc_status = _rpc_status;
33531 :
33532 : /* Result */
33533 0 : NDR_ZERO_STRUCT(state->orig.out.result);
33534 :
33535 0 : state->out_mem_ctx = talloc_named_const(state, 0,
33536 : "dcerpc_clusapi_CreateGroupEnum_out_memory");
33537 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33538 0 : return tevent_req_post(req, ev);
33539 : }
33540 :
33541 : /* make a temporary copy, that we pass to the dispatch function */
33542 0 : state->tmp = state->orig;
33543 :
33544 0 : subreq = dcerpc_clusapi_CreateGroupEnum_r_send(state, ev, h, &state->tmp);
33545 0 : if (tevent_req_nomem(subreq, req)) {
33546 0 : return tevent_req_post(req, ev);
33547 : }
33548 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupEnum_done, req);
33549 0 : return req;
33550 : }
33551 :
33552 0 : static void dcerpc_clusapi_CreateGroupEnum_done(struct tevent_req *subreq)
33553 : {
33554 0 : struct tevent_req *req = tevent_req_callback_data(
33555 : subreq, struct tevent_req);
33556 0 : struct dcerpc_clusapi_CreateGroupEnum_state *state = tevent_req_data(
33557 : req, struct dcerpc_clusapi_CreateGroupEnum_state);
33558 : NTSTATUS status;
33559 : TALLOC_CTX *mem_ctx;
33560 :
33561 0 : if (state->out_mem_ctx) {
33562 0 : mem_ctx = state->out_mem_ctx;
33563 : } else {
33564 0 : mem_ctx = state;
33565 : }
33566 :
33567 0 : status = dcerpc_clusapi_CreateGroupEnum_r_recv(subreq, mem_ctx);
33568 0 : TALLOC_FREE(subreq);
33569 0 : if (tevent_req_nterror(req, status)) {
33570 0 : return;
33571 : }
33572 :
33573 : /* Copy out parameters */
33574 0 : *state->orig.out.ppResultList = *state->tmp.out.ppResultList;
33575 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
33576 :
33577 : /* Copy result */
33578 0 : state->orig.out.result = state->tmp.out.result;
33579 :
33580 : /* Reset temporary structure */
33581 0 : NDR_ZERO_STRUCT(state->tmp);
33582 :
33583 0 : tevent_req_done(req);
33584 : }
33585 :
33586 0 : NTSTATUS dcerpc_clusapi_CreateGroupEnum_recv(struct tevent_req *req,
33587 : TALLOC_CTX *mem_ctx,
33588 : WERROR *result)
33589 : {
33590 0 : struct dcerpc_clusapi_CreateGroupEnum_state *state = tevent_req_data(
33591 : req, struct dcerpc_clusapi_CreateGroupEnum_state);
33592 : NTSTATUS status;
33593 :
33594 0 : if (tevent_req_is_nterror(req, &status)) {
33595 0 : tevent_req_received(req);
33596 0 : return status;
33597 : }
33598 :
33599 : /* Steal possible out parameters to the callers context */
33600 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33601 :
33602 : /* Return result */
33603 0 : *result = state->orig.out.result;
33604 :
33605 0 : tevent_req_received(req);
33606 0 : return NT_STATUS_OK;
33607 : }
33608 :
33609 0 : NTSTATUS dcerpc_clusapi_CreateGroupEnum(struct dcerpc_binding_handle *h,
33610 : TALLOC_CTX *mem_ctx,
33611 : struct policy_handle _hCluster /* [in] */,
33612 : uint8_t *_pProperties /* [in] [size_is(cbProperties),unique] */,
33613 : uint32_t _cbProperties /* [in] */,
33614 : uint8_t *_pRoProperties /* [in] [size_is(cbRoProperties),unique] */,
33615 : uint32_t _cbRoProperties /* [in] */,
33616 : struct GROUP_ENUM_LIST **_ppResultList /* [out] [ref] */,
33617 : WERROR *_rpc_status /* [out] [ref] */,
33618 : WERROR *result)
33619 : {
33620 : struct clusapi_CreateGroupEnum r;
33621 : NTSTATUS status;
33622 :
33623 : /* In parameters */
33624 0 : r.in.hCluster = _hCluster;
33625 0 : r.in.pProperties = _pProperties;
33626 0 : r.in.cbProperties = _cbProperties;
33627 0 : r.in.pRoProperties = _pRoProperties;
33628 0 : r.in.cbRoProperties = _cbRoProperties;
33629 :
33630 : /* Out parameters */
33631 0 : r.out.ppResultList = _ppResultList;
33632 0 : r.out.rpc_status = _rpc_status;
33633 :
33634 : /* Result */
33635 0 : NDR_ZERO_STRUCT(r.out.result);
33636 :
33637 0 : status = dcerpc_clusapi_CreateGroupEnum_r(h, mem_ctx, &r);
33638 0 : if (!NT_STATUS_IS_OK(status)) {
33639 0 : return status;
33640 : }
33641 :
33642 : /* Return variables */
33643 0 : *_ppResultList = *r.out.ppResultList;
33644 0 : *_rpc_status = *r.out.rpc_status;
33645 :
33646 : /* Return result */
33647 0 : *result = r.out.result;
33648 :
33649 0 : return NT_STATUS_OK;
33650 : }
33651 :
33652 : struct dcerpc_clusapi_CreateResourceEnum_r_state {
33653 : TALLOC_CTX *out_mem_ctx;
33654 : };
33655 :
33656 : static void dcerpc_clusapi_CreateResourceEnum_r_done(struct tevent_req *subreq);
33657 :
33658 0 : struct tevent_req *dcerpc_clusapi_CreateResourceEnum_r_send(TALLOC_CTX *mem_ctx,
33659 : struct tevent_context *ev,
33660 : struct dcerpc_binding_handle *h,
33661 : struct clusapi_CreateResourceEnum *r)
33662 : {
33663 : struct tevent_req *req;
33664 : struct dcerpc_clusapi_CreateResourceEnum_r_state *state;
33665 : struct tevent_req *subreq;
33666 :
33667 0 : req = tevent_req_create(mem_ctx, &state,
33668 : struct dcerpc_clusapi_CreateResourceEnum_r_state);
33669 0 : if (req == NULL) {
33670 0 : return NULL;
33671 : }
33672 :
33673 0 : state->out_mem_ctx = talloc_new(state);
33674 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33675 0 : return tevent_req_post(req, ev);
33676 : }
33677 :
33678 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
33679 : NULL, &ndr_table_clusapi,
33680 0 : NDR_CLUSAPI_CREATERESOURCEENUM, state->out_mem_ctx, r);
33681 0 : if (tevent_req_nomem(subreq, req)) {
33682 0 : return tevent_req_post(req, ev);
33683 : }
33684 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResourceEnum_r_done, req);
33685 :
33686 0 : return req;
33687 : }
33688 :
33689 0 : static void dcerpc_clusapi_CreateResourceEnum_r_done(struct tevent_req *subreq)
33690 : {
33691 0 : struct tevent_req *req =
33692 0 : tevent_req_callback_data(subreq,
33693 : struct tevent_req);
33694 : NTSTATUS status;
33695 :
33696 0 : status = dcerpc_binding_handle_call_recv(subreq);
33697 0 : TALLOC_FREE(subreq);
33698 0 : if (tevent_req_nterror(req, status)) {
33699 0 : return;
33700 : }
33701 :
33702 0 : tevent_req_done(req);
33703 : }
33704 :
33705 0 : NTSTATUS dcerpc_clusapi_CreateResourceEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
33706 : {
33707 0 : struct dcerpc_clusapi_CreateResourceEnum_r_state *state =
33708 0 : tevent_req_data(req,
33709 : struct dcerpc_clusapi_CreateResourceEnum_r_state);
33710 : NTSTATUS status;
33711 :
33712 0 : if (tevent_req_is_nterror(req, &status)) {
33713 0 : tevent_req_received(req);
33714 0 : return status;
33715 : }
33716 :
33717 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33718 :
33719 0 : tevent_req_received(req);
33720 0 : return NT_STATUS_OK;
33721 : }
33722 :
33723 0 : NTSTATUS dcerpc_clusapi_CreateResourceEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateResourceEnum *r)
33724 : {
33725 : NTSTATUS status;
33726 :
33727 0 : status = dcerpc_binding_handle_call(h,
33728 : NULL, &ndr_table_clusapi,
33729 : NDR_CLUSAPI_CREATERESOURCEENUM, mem_ctx, r);
33730 :
33731 0 : return status;
33732 : }
33733 :
33734 : struct dcerpc_clusapi_CreateResourceEnum_state {
33735 : struct clusapi_CreateResourceEnum orig;
33736 : struct clusapi_CreateResourceEnum tmp;
33737 : TALLOC_CTX *out_mem_ctx;
33738 : };
33739 :
33740 : static void dcerpc_clusapi_CreateResourceEnum_done(struct tevent_req *subreq);
33741 :
33742 0 : struct tevent_req *dcerpc_clusapi_CreateResourceEnum_send(TALLOC_CTX *mem_ctx,
33743 : struct tevent_context *ev,
33744 : struct dcerpc_binding_handle *h,
33745 : struct policy_handle _hCluster /* [in] */,
33746 : uint8_t *_pProperties /* [in] [size_is(cbProperties),unique] */,
33747 : uint32_t _cbProperties /* [in] */,
33748 : uint8_t *_pRoProperties /* [in] [size_is(cbRoProperties),unique] */,
33749 : uint32_t _cbRoProperties /* [in] */,
33750 : struct RESOURCE_ENUM_LIST **_ppResultList /* [out] [ref] */,
33751 : WERROR *_rpc_status /* [out] [ref] */)
33752 : {
33753 : struct tevent_req *req;
33754 : struct dcerpc_clusapi_CreateResourceEnum_state *state;
33755 : struct tevent_req *subreq;
33756 :
33757 0 : req = tevent_req_create(mem_ctx, &state,
33758 : struct dcerpc_clusapi_CreateResourceEnum_state);
33759 0 : if (req == NULL) {
33760 0 : return NULL;
33761 : }
33762 0 : state->out_mem_ctx = NULL;
33763 :
33764 : /* In parameters */
33765 0 : state->orig.in.hCluster = _hCluster;
33766 0 : state->orig.in.pProperties = _pProperties;
33767 0 : state->orig.in.cbProperties = _cbProperties;
33768 0 : state->orig.in.pRoProperties = _pRoProperties;
33769 0 : state->orig.in.cbRoProperties = _cbRoProperties;
33770 :
33771 : /* Out parameters */
33772 0 : state->orig.out.ppResultList = _ppResultList;
33773 0 : state->orig.out.rpc_status = _rpc_status;
33774 :
33775 : /* Result */
33776 0 : NDR_ZERO_STRUCT(state->orig.out.result);
33777 :
33778 0 : state->out_mem_ctx = talloc_named_const(state, 0,
33779 : "dcerpc_clusapi_CreateResourceEnum_out_memory");
33780 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33781 0 : return tevent_req_post(req, ev);
33782 : }
33783 :
33784 : /* make a temporary copy, that we pass to the dispatch function */
33785 0 : state->tmp = state->orig;
33786 :
33787 0 : subreq = dcerpc_clusapi_CreateResourceEnum_r_send(state, ev, h, &state->tmp);
33788 0 : if (tevent_req_nomem(subreq, req)) {
33789 0 : return tevent_req_post(req, ev);
33790 : }
33791 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateResourceEnum_done, req);
33792 0 : return req;
33793 : }
33794 :
33795 0 : static void dcerpc_clusapi_CreateResourceEnum_done(struct tevent_req *subreq)
33796 : {
33797 0 : struct tevent_req *req = tevent_req_callback_data(
33798 : subreq, struct tevent_req);
33799 0 : struct dcerpc_clusapi_CreateResourceEnum_state *state = tevent_req_data(
33800 : req, struct dcerpc_clusapi_CreateResourceEnum_state);
33801 : NTSTATUS status;
33802 : TALLOC_CTX *mem_ctx;
33803 :
33804 0 : if (state->out_mem_ctx) {
33805 0 : mem_ctx = state->out_mem_ctx;
33806 : } else {
33807 0 : mem_ctx = state;
33808 : }
33809 :
33810 0 : status = dcerpc_clusapi_CreateResourceEnum_r_recv(subreq, mem_ctx);
33811 0 : TALLOC_FREE(subreq);
33812 0 : if (tevent_req_nterror(req, status)) {
33813 0 : return;
33814 : }
33815 :
33816 : /* Copy out parameters */
33817 0 : *state->orig.out.ppResultList = *state->tmp.out.ppResultList;
33818 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
33819 :
33820 : /* Copy result */
33821 0 : state->orig.out.result = state->tmp.out.result;
33822 :
33823 : /* Reset temporary structure */
33824 0 : NDR_ZERO_STRUCT(state->tmp);
33825 :
33826 0 : tevent_req_done(req);
33827 : }
33828 :
33829 0 : NTSTATUS dcerpc_clusapi_CreateResourceEnum_recv(struct tevent_req *req,
33830 : TALLOC_CTX *mem_ctx,
33831 : WERROR *result)
33832 : {
33833 0 : struct dcerpc_clusapi_CreateResourceEnum_state *state = tevent_req_data(
33834 : req, struct dcerpc_clusapi_CreateResourceEnum_state);
33835 : NTSTATUS status;
33836 :
33837 0 : if (tevent_req_is_nterror(req, &status)) {
33838 0 : tevent_req_received(req);
33839 0 : return status;
33840 : }
33841 :
33842 : /* Steal possible out parameters to the callers context */
33843 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33844 :
33845 : /* Return result */
33846 0 : *result = state->orig.out.result;
33847 :
33848 0 : tevent_req_received(req);
33849 0 : return NT_STATUS_OK;
33850 : }
33851 :
33852 0 : NTSTATUS dcerpc_clusapi_CreateResourceEnum(struct dcerpc_binding_handle *h,
33853 : TALLOC_CTX *mem_ctx,
33854 : struct policy_handle _hCluster /* [in] */,
33855 : uint8_t *_pProperties /* [in] [size_is(cbProperties),unique] */,
33856 : uint32_t _cbProperties /* [in] */,
33857 : uint8_t *_pRoProperties /* [in] [size_is(cbRoProperties),unique] */,
33858 : uint32_t _cbRoProperties /* [in] */,
33859 : struct RESOURCE_ENUM_LIST **_ppResultList /* [out] [ref] */,
33860 : WERROR *_rpc_status /* [out] [ref] */,
33861 : WERROR *result)
33862 : {
33863 : struct clusapi_CreateResourceEnum r;
33864 : NTSTATUS status;
33865 :
33866 : /* In parameters */
33867 0 : r.in.hCluster = _hCluster;
33868 0 : r.in.pProperties = _pProperties;
33869 0 : r.in.cbProperties = _cbProperties;
33870 0 : r.in.pRoProperties = _pRoProperties;
33871 0 : r.in.cbRoProperties = _cbRoProperties;
33872 :
33873 : /* Out parameters */
33874 0 : r.out.ppResultList = _ppResultList;
33875 0 : r.out.rpc_status = _rpc_status;
33876 :
33877 : /* Result */
33878 0 : NDR_ZERO_STRUCT(r.out.result);
33879 :
33880 0 : status = dcerpc_clusapi_CreateResourceEnum_r(h, mem_ctx, &r);
33881 0 : if (!NT_STATUS_IS_OK(status)) {
33882 0 : return status;
33883 : }
33884 :
33885 : /* Return variables */
33886 0 : *_ppResultList = *r.out.ppResultList;
33887 0 : *_rpc_status = *r.out.rpc_status;
33888 :
33889 : /* Return result */
33890 0 : *result = r.out.result;
33891 :
33892 0 : return NT_STATUS_OK;
33893 : }
33894 :
33895 : struct dcerpc_clusapi_ExecuteReadBatch_r_state {
33896 : TALLOC_CTX *out_mem_ctx;
33897 : };
33898 :
33899 : static void dcerpc_clusapi_ExecuteReadBatch_r_done(struct tevent_req *subreq);
33900 :
33901 0 : struct tevent_req *dcerpc_clusapi_ExecuteReadBatch_r_send(TALLOC_CTX *mem_ctx,
33902 : struct tevent_context *ev,
33903 : struct dcerpc_binding_handle *h,
33904 : struct clusapi_ExecuteReadBatch *r)
33905 : {
33906 : struct tevent_req *req;
33907 : struct dcerpc_clusapi_ExecuteReadBatch_r_state *state;
33908 : struct tevent_req *subreq;
33909 :
33910 0 : req = tevent_req_create(mem_ctx, &state,
33911 : struct dcerpc_clusapi_ExecuteReadBatch_r_state);
33912 0 : if (req == NULL) {
33913 0 : return NULL;
33914 : }
33915 :
33916 0 : state->out_mem_ctx = talloc_new(state);
33917 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
33918 0 : return tevent_req_post(req, ev);
33919 : }
33920 :
33921 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
33922 : NULL, &ndr_table_clusapi,
33923 0 : NDR_CLUSAPI_EXECUTEREADBATCH, state->out_mem_ctx, r);
33924 0 : if (tevent_req_nomem(subreq, req)) {
33925 0 : return tevent_req_post(req, ev);
33926 : }
33927 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteReadBatch_r_done, req);
33928 :
33929 0 : return req;
33930 : }
33931 :
33932 0 : static void dcerpc_clusapi_ExecuteReadBatch_r_done(struct tevent_req *subreq)
33933 : {
33934 0 : struct tevent_req *req =
33935 0 : tevent_req_callback_data(subreq,
33936 : struct tevent_req);
33937 : NTSTATUS status;
33938 :
33939 0 : status = dcerpc_binding_handle_call_recv(subreq);
33940 0 : TALLOC_FREE(subreq);
33941 0 : if (tevent_req_nterror(req, status)) {
33942 0 : return;
33943 : }
33944 :
33945 0 : tevent_req_done(req);
33946 : }
33947 :
33948 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatch_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
33949 : {
33950 0 : struct dcerpc_clusapi_ExecuteReadBatch_r_state *state =
33951 0 : tevent_req_data(req,
33952 : struct dcerpc_clusapi_ExecuteReadBatch_r_state);
33953 : NTSTATUS status;
33954 :
33955 0 : if (tevent_req_is_nterror(req, &status)) {
33956 0 : tevent_req_received(req);
33957 0 : return status;
33958 : }
33959 :
33960 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
33961 :
33962 0 : tevent_req_received(req);
33963 0 : return NT_STATUS_OK;
33964 : }
33965 :
33966 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatch_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ExecuteReadBatch *r)
33967 : {
33968 : NTSTATUS status;
33969 :
33970 0 : status = dcerpc_binding_handle_call(h,
33971 : NULL, &ndr_table_clusapi,
33972 : NDR_CLUSAPI_EXECUTEREADBATCH, mem_ctx, r);
33973 :
33974 0 : return status;
33975 : }
33976 :
33977 : struct dcerpc_clusapi_ExecuteReadBatch_state {
33978 : struct clusapi_ExecuteReadBatch orig;
33979 : struct clusapi_ExecuteReadBatch tmp;
33980 : TALLOC_CTX *out_mem_ctx;
33981 : };
33982 :
33983 : static void dcerpc_clusapi_ExecuteReadBatch_done(struct tevent_req *subreq);
33984 :
33985 0 : struct tevent_req *dcerpc_clusapi_ExecuteReadBatch_send(TALLOC_CTX *mem_ctx,
33986 : struct tevent_context *ev,
33987 : struct dcerpc_binding_handle *h,
33988 : struct policy_handle _hKey /* [in] */,
33989 : uint32_t _cbInData /* [in] */,
33990 : uint8_t *_lpInData /* [in] [ref,size_is(cbInData)] */,
33991 : uint32_t *_cbOutData /* [out] [ref] */,
33992 : uint8_t **_lpOutData /* [out] [ref,size_is(,*cbOutData)] */,
33993 : WERROR *_rpc_status /* [out] [ref] */)
33994 : {
33995 : struct tevent_req *req;
33996 : struct dcerpc_clusapi_ExecuteReadBatch_state *state;
33997 : struct tevent_req *subreq;
33998 :
33999 0 : req = tevent_req_create(mem_ctx, &state,
34000 : struct dcerpc_clusapi_ExecuteReadBatch_state);
34001 0 : if (req == NULL) {
34002 0 : return NULL;
34003 : }
34004 0 : state->out_mem_ctx = NULL;
34005 :
34006 : /* In parameters */
34007 0 : state->orig.in.hKey = _hKey;
34008 0 : state->orig.in.cbInData = _cbInData;
34009 0 : state->orig.in.lpInData = _lpInData;
34010 :
34011 : /* Out parameters */
34012 0 : state->orig.out.cbOutData = _cbOutData;
34013 0 : state->orig.out.lpOutData = _lpOutData;
34014 0 : state->orig.out.rpc_status = _rpc_status;
34015 :
34016 : /* Result */
34017 0 : NDR_ZERO_STRUCT(state->orig.out.result);
34018 :
34019 0 : state->out_mem_ctx = talloc_named_const(state, 0,
34020 : "dcerpc_clusapi_ExecuteReadBatch_out_memory");
34021 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34022 0 : return tevent_req_post(req, ev);
34023 : }
34024 :
34025 : /* make a temporary copy, that we pass to the dispatch function */
34026 0 : state->tmp = state->orig;
34027 :
34028 0 : subreq = dcerpc_clusapi_ExecuteReadBatch_r_send(state, ev, h, &state->tmp);
34029 0 : if (tevent_req_nomem(subreq, req)) {
34030 0 : return tevent_req_post(req, ev);
34031 : }
34032 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteReadBatch_done, req);
34033 0 : return req;
34034 : }
34035 :
34036 0 : static void dcerpc_clusapi_ExecuteReadBatch_done(struct tevent_req *subreq)
34037 : {
34038 0 : struct tevent_req *req = tevent_req_callback_data(
34039 : subreq, struct tevent_req);
34040 0 : struct dcerpc_clusapi_ExecuteReadBatch_state *state = tevent_req_data(
34041 : req, struct dcerpc_clusapi_ExecuteReadBatch_state);
34042 : NTSTATUS status;
34043 : TALLOC_CTX *mem_ctx;
34044 :
34045 0 : if (state->out_mem_ctx) {
34046 0 : mem_ctx = state->out_mem_ctx;
34047 : } else {
34048 0 : mem_ctx = state;
34049 : }
34050 :
34051 0 : status = dcerpc_clusapi_ExecuteReadBatch_r_recv(subreq, mem_ctx);
34052 0 : TALLOC_FREE(subreq);
34053 0 : if (tevent_req_nterror(req, status)) {
34054 0 : return;
34055 : }
34056 :
34057 : /* Copy out parameters */
34058 0 : *state->orig.out.cbOutData = *state->tmp.out.cbOutData;
34059 0 : *state->orig.out.lpOutData = *state->tmp.out.lpOutData;
34060 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
34061 :
34062 : /* Copy result */
34063 0 : state->orig.out.result = state->tmp.out.result;
34064 :
34065 : /* Reset temporary structure */
34066 0 : NDR_ZERO_STRUCT(state->tmp);
34067 :
34068 0 : tevent_req_done(req);
34069 : }
34070 :
34071 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatch_recv(struct tevent_req *req,
34072 : TALLOC_CTX *mem_ctx,
34073 : WERROR *result)
34074 : {
34075 0 : struct dcerpc_clusapi_ExecuteReadBatch_state *state = tevent_req_data(
34076 : req, struct dcerpc_clusapi_ExecuteReadBatch_state);
34077 : NTSTATUS status;
34078 :
34079 0 : if (tevent_req_is_nterror(req, &status)) {
34080 0 : tevent_req_received(req);
34081 0 : return status;
34082 : }
34083 :
34084 : /* Steal possible out parameters to the callers context */
34085 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34086 :
34087 : /* Return result */
34088 0 : *result = state->orig.out.result;
34089 :
34090 0 : tevent_req_received(req);
34091 0 : return NT_STATUS_OK;
34092 : }
34093 :
34094 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatch(struct dcerpc_binding_handle *h,
34095 : TALLOC_CTX *mem_ctx,
34096 : struct policy_handle _hKey /* [in] */,
34097 : uint32_t _cbInData /* [in] */,
34098 : uint8_t *_lpInData /* [in] [ref,size_is(cbInData)] */,
34099 : uint32_t *_cbOutData /* [out] [ref] */,
34100 : uint8_t **_lpOutData /* [out] [ref,size_is(,*cbOutData)] */,
34101 : WERROR *_rpc_status /* [out] [ref] */,
34102 : WERROR *result)
34103 : {
34104 : struct clusapi_ExecuteReadBatch r;
34105 : NTSTATUS status;
34106 :
34107 : /* In parameters */
34108 0 : r.in.hKey = _hKey;
34109 0 : r.in.cbInData = _cbInData;
34110 0 : r.in.lpInData = _lpInData;
34111 :
34112 : /* Out parameters */
34113 0 : r.out.cbOutData = _cbOutData;
34114 0 : r.out.lpOutData = _lpOutData;
34115 0 : r.out.rpc_status = _rpc_status;
34116 :
34117 : /* Result */
34118 0 : NDR_ZERO_STRUCT(r.out.result);
34119 :
34120 0 : status = dcerpc_clusapi_ExecuteReadBatch_r(h, mem_ctx, &r);
34121 0 : if (!NT_STATUS_IS_OK(status)) {
34122 0 : return status;
34123 : }
34124 :
34125 : /* Return variables */
34126 0 : *_cbOutData = *r.out.cbOutData;
34127 0 : *_lpOutData = *r.out.lpOutData;
34128 0 : *_rpc_status = *r.out.rpc_status;
34129 :
34130 : /* Return result */
34131 0 : *result = r.out.result;
34132 :
34133 0 : return NT_STATUS_OK;
34134 : }
34135 :
34136 : struct dcerpc_clusapi_RestartResource_r_state {
34137 : TALLOC_CTX *out_mem_ctx;
34138 : };
34139 :
34140 : static void dcerpc_clusapi_RestartResource_r_done(struct tevent_req *subreq);
34141 :
34142 0 : struct tevent_req *dcerpc_clusapi_RestartResource_r_send(TALLOC_CTX *mem_ctx,
34143 : struct tevent_context *ev,
34144 : struct dcerpc_binding_handle *h,
34145 : struct clusapi_RestartResource *r)
34146 : {
34147 : struct tevent_req *req;
34148 : struct dcerpc_clusapi_RestartResource_r_state *state;
34149 : struct tevent_req *subreq;
34150 :
34151 0 : req = tevent_req_create(mem_ctx, &state,
34152 : struct dcerpc_clusapi_RestartResource_r_state);
34153 0 : if (req == NULL) {
34154 0 : return NULL;
34155 : }
34156 :
34157 0 : state->out_mem_ctx = talloc_new(state);
34158 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34159 0 : return tevent_req_post(req, ev);
34160 : }
34161 :
34162 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
34163 : NULL, &ndr_table_clusapi,
34164 0 : NDR_CLUSAPI_RESTARTRESOURCE, state->out_mem_ctx, r);
34165 0 : if (tevent_req_nomem(subreq, req)) {
34166 0 : return tevent_req_post(req, ev);
34167 : }
34168 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RestartResource_r_done, req);
34169 :
34170 0 : return req;
34171 : }
34172 :
34173 0 : static void dcerpc_clusapi_RestartResource_r_done(struct tevent_req *subreq)
34174 : {
34175 0 : struct tevent_req *req =
34176 0 : tevent_req_callback_data(subreq,
34177 : struct tevent_req);
34178 : NTSTATUS status;
34179 :
34180 0 : status = dcerpc_binding_handle_call_recv(subreq);
34181 0 : TALLOC_FREE(subreq);
34182 0 : if (tevent_req_nterror(req, status)) {
34183 0 : return;
34184 : }
34185 :
34186 0 : tevent_req_done(req);
34187 : }
34188 :
34189 0 : NTSTATUS dcerpc_clusapi_RestartResource_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
34190 : {
34191 0 : struct dcerpc_clusapi_RestartResource_r_state *state =
34192 0 : tevent_req_data(req,
34193 : struct dcerpc_clusapi_RestartResource_r_state);
34194 : NTSTATUS status;
34195 :
34196 0 : if (tevent_req_is_nterror(req, &status)) {
34197 0 : tevent_req_received(req);
34198 0 : return status;
34199 : }
34200 :
34201 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34202 :
34203 0 : tevent_req_received(req);
34204 0 : return NT_STATUS_OK;
34205 : }
34206 :
34207 0 : NTSTATUS dcerpc_clusapi_RestartResource_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RestartResource *r)
34208 : {
34209 : NTSTATUS status;
34210 :
34211 0 : status = dcerpc_binding_handle_call(h,
34212 : NULL, &ndr_table_clusapi,
34213 : NDR_CLUSAPI_RESTARTRESOURCE, mem_ctx, r);
34214 :
34215 0 : return status;
34216 : }
34217 :
34218 : struct dcerpc_clusapi_RestartResource_state {
34219 : struct clusapi_RestartResource orig;
34220 : struct clusapi_RestartResource tmp;
34221 : TALLOC_CTX *out_mem_ctx;
34222 : };
34223 :
34224 : static void dcerpc_clusapi_RestartResource_done(struct tevent_req *subreq);
34225 :
34226 0 : struct tevent_req *dcerpc_clusapi_RestartResource_send(TALLOC_CTX *mem_ctx,
34227 : struct tevent_context *ev,
34228 : struct dcerpc_binding_handle *h,
34229 : struct policy_handle _hResource /* [in] */,
34230 : uint32_t _dwFlags /* [in] */,
34231 : WERROR *_rpc_status /* [out] [ref] */)
34232 : {
34233 : struct tevent_req *req;
34234 : struct dcerpc_clusapi_RestartResource_state *state;
34235 : struct tevent_req *subreq;
34236 :
34237 0 : req = tevent_req_create(mem_ctx, &state,
34238 : struct dcerpc_clusapi_RestartResource_state);
34239 0 : if (req == NULL) {
34240 0 : return NULL;
34241 : }
34242 0 : state->out_mem_ctx = NULL;
34243 :
34244 : /* In parameters */
34245 0 : state->orig.in.hResource = _hResource;
34246 0 : state->orig.in.dwFlags = _dwFlags;
34247 :
34248 : /* Out parameters */
34249 0 : state->orig.out.rpc_status = _rpc_status;
34250 :
34251 : /* Result */
34252 0 : NDR_ZERO_STRUCT(state->orig.out.result);
34253 :
34254 0 : state->out_mem_ctx = talloc_named_const(state, 0,
34255 : "dcerpc_clusapi_RestartResource_out_memory");
34256 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34257 0 : return tevent_req_post(req, ev);
34258 : }
34259 :
34260 : /* make a temporary copy, that we pass to the dispatch function */
34261 0 : state->tmp = state->orig;
34262 :
34263 0 : subreq = dcerpc_clusapi_RestartResource_r_send(state, ev, h, &state->tmp);
34264 0 : if (tevent_req_nomem(subreq, req)) {
34265 0 : return tevent_req_post(req, ev);
34266 : }
34267 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RestartResource_done, req);
34268 0 : return req;
34269 : }
34270 :
34271 0 : static void dcerpc_clusapi_RestartResource_done(struct tevent_req *subreq)
34272 : {
34273 0 : struct tevent_req *req = tevent_req_callback_data(
34274 : subreq, struct tevent_req);
34275 0 : struct dcerpc_clusapi_RestartResource_state *state = tevent_req_data(
34276 : req, struct dcerpc_clusapi_RestartResource_state);
34277 : NTSTATUS status;
34278 : TALLOC_CTX *mem_ctx;
34279 :
34280 0 : if (state->out_mem_ctx) {
34281 0 : mem_ctx = state->out_mem_ctx;
34282 : } else {
34283 0 : mem_ctx = state;
34284 : }
34285 :
34286 0 : status = dcerpc_clusapi_RestartResource_r_recv(subreq, mem_ctx);
34287 0 : TALLOC_FREE(subreq);
34288 0 : if (tevent_req_nterror(req, status)) {
34289 0 : return;
34290 : }
34291 :
34292 : /* Copy out parameters */
34293 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
34294 :
34295 : /* Copy result */
34296 0 : state->orig.out.result = state->tmp.out.result;
34297 :
34298 : /* Reset temporary structure */
34299 0 : NDR_ZERO_STRUCT(state->tmp);
34300 :
34301 0 : tevent_req_done(req);
34302 : }
34303 :
34304 0 : NTSTATUS dcerpc_clusapi_RestartResource_recv(struct tevent_req *req,
34305 : TALLOC_CTX *mem_ctx,
34306 : WERROR *result)
34307 : {
34308 0 : struct dcerpc_clusapi_RestartResource_state *state = tevent_req_data(
34309 : req, struct dcerpc_clusapi_RestartResource_state);
34310 : NTSTATUS status;
34311 :
34312 0 : if (tevent_req_is_nterror(req, &status)) {
34313 0 : tevent_req_received(req);
34314 0 : return status;
34315 : }
34316 :
34317 : /* Steal possible out parameters to the callers context */
34318 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34319 :
34320 : /* Return result */
34321 0 : *result = state->orig.out.result;
34322 :
34323 0 : tevent_req_received(req);
34324 0 : return NT_STATUS_OK;
34325 : }
34326 :
34327 0 : NTSTATUS dcerpc_clusapi_RestartResource(struct dcerpc_binding_handle *h,
34328 : TALLOC_CTX *mem_ctx,
34329 : struct policy_handle _hResource /* [in] */,
34330 : uint32_t _dwFlags /* [in] */,
34331 : WERROR *_rpc_status /* [out] [ref] */,
34332 : WERROR *result)
34333 : {
34334 : struct clusapi_RestartResource r;
34335 : NTSTATUS status;
34336 :
34337 : /* In parameters */
34338 0 : r.in.hResource = _hResource;
34339 0 : r.in.dwFlags = _dwFlags;
34340 :
34341 : /* Out parameters */
34342 0 : r.out.rpc_status = _rpc_status;
34343 :
34344 : /* Result */
34345 0 : NDR_ZERO_STRUCT(r.out.result);
34346 :
34347 0 : status = dcerpc_clusapi_RestartResource_r(h, mem_ctx, &r);
34348 0 : if (!NT_STATUS_IS_OK(status)) {
34349 0 : return status;
34350 : }
34351 :
34352 : /* Return variables */
34353 0 : *_rpc_status = *r.out.rpc_status;
34354 :
34355 : /* Return result */
34356 0 : *result = r.out.result;
34357 :
34358 0 : return NT_STATUS_OK;
34359 : }
34360 :
34361 : struct dcerpc_clusapi_GetNotifyAsync_r_state {
34362 : TALLOC_CTX *out_mem_ctx;
34363 : };
34364 :
34365 : static void dcerpc_clusapi_GetNotifyAsync_r_done(struct tevent_req *subreq);
34366 :
34367 0 : struct tevent_req *dcerpc_clusapi_GetNotifyAsync_r_send(TALLOC_CTX *mem_ctx,
34368 : struct tevent_context *ev,
34369 : struct dcerpc_binding_handle *h,
34370 : struct clusapi_GetNotifyAsync *r)
34371 : {
34372 : struct tevent_req *req;
34373 : struct dcerpc_clusapi_GetNotifyAsync_r_state *state;
34374 : struct tevent_req *subreq;
34375 :
34376 0 : req = tevent_req_create(mem_ctx, &state,
34377 : struct dcerpc_clusapi_GetNotifyAsync_r_state);
34378 0 : if (req == NULL) {
34379 0 : return NULL;
34380 : }
34381 :
34382 0 : state->out_mem_ctx = talloc_new(state);
34383 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34384 0 : return tevent_req_post(req, ev);
34385 : }
34386 :
34387 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
34388 : NULL, &ndr_table_clusapi,
34389 0 : NDR_CLUSAPI_GETNOTIFYASYNC, state->out_mem_ctx, r);
34390 0 : if (tevent_req_nomem(subreq, req)) {
34391 0 : return tevent_req_post(req, ev);
34392 : }
34393 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotifyAsync_r_done, req);
34394 :
34395 0 : return req;
34396 : }
34397 :
34398 0 : static void dcerpc_clusapi_GetNotifyAsync_r_done(struct tevent_req *subreq)
34399 : {
34400 0 : struct tevent_req *req =
34401 0 : tevent_req_callback_data(subreq,
34402 : struct tevent_req);
34403 : NTSTATUS status;
34404 :
34405 0 : status = dcerpc_binding_handle_call_recv(subreq);
34406 0 : TALLOC_FREE(subreq);
34407 0 : if (tevent_req_nterror(req, status)) {
34408 0 : return;
34409 : }
34410 :
34411 0 : tevent_req_done(req);
34412 : }
34413 :
34414 0 : NTSTATUS dcerpc_clusapi_GetNotifyAsync_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
34415 : {
34416 0 : struct dcerpc_clusapi_GetNotifyAsync_r_state *state =
34417 0 : tevent_req_data(req,
34418 : struct dcerpc_clusapi_GetNotifyAsync_r_state);
34419 : NTSTATUS status;
34420 :
34421 0 : if (tevent_req_is_nterror(req, &status)) {
34422 0 : tevent_req_received(req);
34423 0 : return status;
34424 : }
34425 :
34426 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34427 :
34428 0 : tevent_req_received(req);
34429 0 : return NT_STATUS_OK;
34430 : }
34431 :
34432 0 : NTSTATUS dcerpc_clusapi_GetNotifyAsync_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GetNotifyAsync *r)
34433 : {
34434 : NTSTATUS status;
34435 :
34436 0 : status = dcerpc_binding_handle_call(h,
34437 : NULL, &ndr_table_clusapi,
34438 : NDR_CLUSAPI_GETNOTIFYASYNC, mem_ctx, r);
34439 :
34440 0 : return status;
34441 : }
34442 :
34443 : struct dcerpc_clusapi_GetNotifyAsync_state {
34444 : struct clusapi_GetNotifyAsync orig;
34445 : struct clusapi_GetNotifyAsync tmp;
34446 : TALLOC_CTX *out_mem_ctx;
34447 : };
34448 :
34449 : static void dcerpc_clusapi_GetNotifyAsync_done(struct tevent_req *subreq);
34450 :
34451 0 : struct tevent_req *dcerpc_clusapi_GetNotifyAsync_send(TALLOC_CTX *mem_ctx,
34452 : struct tevent_context *ev,
34453 : struct dcerpc_binding_handle *h,
34454 : struct policy_handle _hNotify /* [in] */,
34455 : struct NOTIFICATION_DATA_ASYNC_RPC **_Notifications /* [out] [ref,size_is(,*dwNumNotifications)] */,
34456 : uint32_t *_dwNumNotifications /* [out] [ref] */)
34457 : {
34458 : struct tevent_req *req;
34459 : struct dcerpc_clusapi_GetNotifyAsync_state *state;
34460 : struct tevent_req *subreq;
34461 :
34462 0 : req = tevent_req_create(mem_ctx, &state,
34463 : struct dcerpc_clusapi_GetNotifyAsync_state);
34464 0 : if (req == NULL) {
34465 0 : return NULL;
34466 : }
34467 0 : state->out_mem_ctx = NULL;
34468 :
34469 : /* In parameters */
34470 0 : state->orig.in.hNotify = _hNotify;
34471 :
34472 : /* Out parameters */
34473 0 : state->orig.out.Notifications = _Notifications;
34474 0 : state->orig.out.dwNumNotifications = _dwNumNotifications;
34475 :
34476 : /* Result */
34477 0 : NDR_ZERO_STRUCT(state->orig.out.result);
34478 :
34479 0 : state->out_mem_ctx = talloc_named_const(state, 0,
34480 : "dcerpc_clusapi_GetNotifyAsync_out_memory");
34481 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
34482 0 : return tevent_req_post(req, ev);
34483 : }
34484 :
34485 : /* make a temporary copy, that we pass to the dispatch function */
34486 0 : state->tmp = state->orig;
34487 :
34488 0 : subreq = dcerpc_clusapi_GetNotifyAsync_r_send(state, ev, h, &state->tmp);
34489 0 : if (tevent_req_nomem(subreq, req)) {
34490 0 : return tevent_req_post(req, ev);
34491 : }
34492 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GetNotifyAsync_done, req);
34493 0 : return req;
34494 : }
34495 :
34496 0 : static void dcerpc_clusapi_GetNotifyAsync_done(struct tevent_req *subreq)
34497 : {
34498 0 : struct tevent_req *req = tevent_req_callback_data(
34499 : subreq, struct tevent_req);
34500 0 : struct dcerpc_clusapi_GetNotifyAsync_state *state = tevent_req_data(
34501 : req, struct dcerpc_clusapi_GetNotifyAsync_state);
34502 : NTSTATUS status;
34503 : TALLOC_CTX *mem_ctx;
34504 :
34505 0 : if (state->out_mem_ctx) {
34506 0 : mem_ctx = state->out_mem_ctx;
34507 : } else {
34508 0 : mem_ctx = state;
34509 : }
34510 :
34511 0 : status = dcerpc_clusapi_GetNotifyAsync_r_recv(subreq, mem_ctx);
34512 0 : TALLOC_FREE(subreq);
34513 0 : if (tevent_req_nterror(req, status)) {
34514 0 : return;
34515 : }
34516 :
34517 : /* Copy out parameters */
34518 0 : *state->orig.out.Notifications = *state->tmp.out.Notifications;
34519 0 : *state->orig.out.dwNumNotifications = *state->tmp.out.dwNumNotifications;
34520 :
34521 : /* Copy result */
34522 0 : state->orig.out.result = state->tmp.out.result;
34523 :
34524 : /* Reset temporary structure */
34525 0 : NDR_ZERO_STRUCT(state->tmp);
34526 :
34527 0 : tevent_req_done(req);
34528 : }
34529 :
34530 0 : NTSTATUS dcerpc_clusapi_GetNotifyAsync_recv(struct tevent_req *req,
34531 : TALLOC_CTX *mem_ctx,
34532 : WERROR *result)
34533 : {
34534 0 : struct dcerpc_clusapi_GetNotifyAsync_state *state = tevent_req_data(
34535 : req, struct dcerpc_clusapi_GetNotifyAsync_state);
34536 : NTSTATUS status;
34537 :
34538 0 : if (tevent_req_is_nterror(req, &status)) {
34539 0 : tevent_req_received(req);
34540 0 : return status;
34541 : }
34542 :
34543 : /* Steal possible out parameters to the callers context */
34544 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34545 :
34546 : /* Return result */
34547 0 : *result = state->orig.out.result;
34548 :
34549 0 : tevent_req_received(req);
34550 0 : return NT_STATUS_OK;
34551 : }
34552 :
34553 0 : NTSTATUS dcerpc_clusapi_GetNotifyAsync(struct dcerpc_binding_handle *h,
34554 : TALLOC_CTX *mem_ctx,
34555 : struct policy_handle _hNotify /* [in] */,
34556 : struct NOTIFICATION_DATA_ASYNC_RPC **_Notifications /* [out] [ref,size_is(,*dwNumNotifications)] */,
34557 : uint32_t *_dwNumNotifications /* [out] [ref] */,
34558 : WERROR *result)
34559 : {
34560 : struct clusapi_GetNotifyAsync r;
34561 : NTSTATUS status;
34562 :
34563 : /* In parameters */
34564 0 : r.in.hNotify = _hNotify;
34565 :
34566 : /* Out parameters */
34567 0 : r.out.Notifications = _Notifications;
34568 0 : r.out.dwNumNotifications = _dwNumNotifications;
34569 :
34570 : /* Result */
34571 0 : NDR_ZERO_STRUCT(r.out.result);
34572 :
34573 0 : status = dcerpc_clusapi_GetNotifyAsync_r(h, mem_ctx, &r);
34574 0 : if (!NT_STATUS_IS_OK(status)) {
34575 0 : return status;
34576 : }
34577 :
34578 : /* Return variables */
34579 0 : *_Notifications = *r.out.Notifications;
34580 0 : *_dwNumNotifications = *r.out.dwNumNotifications;
34581 :
34582 : /* Return result */
34583 0 : *result = r.out.result;
34584 :
34585 0 : return NT_STATUS_OK;
34586 : }
34587 :
34588 : struct dcerpc_Opnum148NotUsedOnWire_r_state {
34589 : TALLOC_CTX *out_mem_ctx;
34590 : };
34591 :
34592 : static void dcerpc_Opnum148NotUsedOnWire_r_done(struct tevent_req *subreq);
34593 :
34594 0 : struct tevent_req *dcerpc_Opnum148NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
34595 : struct tevent_context *ev,
34596 : struct dcerpc_binding_handle *h,
34597 : struct Opnum148NotUsedOnWire *r)
34598 : {
34599 : struct tevent_req *req;
34600 : struct dcerpc_Opnum148NotUsedOnWire_r_state *state;
34601 : struct tevent_req *subreq;
34602 :
34603 0 : req = tevent_req_create(mem_ctx, &state,
34604 : struct dcerpc_Opnum148NotUsedOnWire_r_state);
34605 0 : if (req == NULL) {
34606 0 : return NULL;
34607 : }
34608 :
34609 0 : state->out_mem_ctx = NULL;
34610 :
34611 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
34612 : NULL, &ndr_table_clusapi,
34613 : NDR_OPNUM148NOTUSEDONWIRE, state, r);
34614 0 : if (tevent_req_nomem(subreq, req)) {
34615 0 : return tevent_req_post(req, ev);
34616 : }
34617 0 : tevent_req_set_callback(subreq, dcerpc_Opnum148NotUsedOnWire_r_done, req);
34618 :
34619 0 : return req;
34620 : }
34621 :
34622 0 : static void dcerpc_Opnum148NotUsedOnWire_r_done(struct tevent_req *subreq)
34623 : {
34624 0 : struct tevent_req *req =
34625 0 : tevent_req_callback_data(subreq,
34626 : struct tevent_req);
34627 : NTSTATUS status;
34628 :
34629 0 : status = dcerpc_binding_handle_call_recv(subreq);
34630 0 : TALLOC_FREE(subreq);
34631 0 : if (tevent_req_nterror(req, status)) {
34632 0 : return;
34633 : }
34634 :
34635 0 : tevent_req_done(req);
34636 : }
34637 :
34638 0 : NTSTATUS dcerpc_Opnum148NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
34639 : {
34640 0 : struct dcerpc_Opnum148NotUsedOnWire_r_state *state =
34641 0 : tevent_req_data(req,
34642 : struct dcerpc_Opnum148NotUsedOnWire_r_state);
34643 : NTSTATUS status;
34644 :
34645 0 : if (tevent_req_is_nterror(req, &status)) {
34646 0 : tevent_req_received(req);
34647 0 : return status;
34648 : }
34649 :
34650 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34651 :
34652 0 : tevent_req_received(req);
34653 0 : return NT_STATUS_OK;
34654 : }
34655 :
34656 0 : NTSTATUS dcerpc_Opnum148NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum148NotUsedOnWire *r)
34657 : {
34658 : NTSTATUS status;
34659 :
34660 0 : status = dcerpc_binding_handle_call(h,
34661 : NULL, &ndr_table_clusapi,
34662 : NDR_OPNUM148NOTUSEDONWIRE, mem_ctx, r);
34663 :
34664 0 : return status;
34665 : }
34666 :
34667 : struct dcerpc_Opnum148NotUsedOnWire_state {
34668 : struct Opnum148NotUsedOnWire orig;
34669 : struct Opnum148NotUsedOnWire tmp;
34670 : TALLOC_CTX *out_mem_ctx;
34671 : };
34672 :
34673 : static void dcerpc_Opnum148NotUsedOnWire_done(struct tevent_req *subreq);
34674 :
34675 0 : struct tevent_req *dcerpc_Opnum148NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
34676 : struct tevent_context *ev,
34677 : struct dcerpc_binding_handle *h)
34678 : {
34679 : struct tevent_req *req;
34680 : struct dcerpc_Opnum148NotUsedOnWire_state *state;
34681 : struct tevent_req *subreq;
34682 :
34683 0 : req = tevent_req_create(mem_ctx, &state,
34684 : struct dcerpc_Opnum148NotUsedOnWire_state);
34685 0 : if (req == NULL) {
34686 0 : return NULL;
34687 : }
34688 0 : state->out_mem_ctx = NULL;
34689 :
34690 : /* In parameters */
34691 :
34692 : /* Out parameters */
34693 :
34694 : /* Result */
34695 0 : NDR_ZERO_STRUCT(state->orig.out.result);
34696 :
34697 : /* make a temporary copy, that we pass to the dispatch function */
34698 0 : state->tmp = state->orig;
34699 :
34700 0 : subreq = dcerpc_Opnum148NotUsedOnWire_r_send(state, ev, h, &state->tmp);
34701 0 : if (tevent_req_nomem(subreq, req)) {
34702 0 : return tevent_req_post(req, ev);
34703 : }
34704 0 : tevent_req_set_callback(subreq, dcerpc_Opnum148NotUsedOnWire_done, req);
34705 0 : return req;
34706 : }
34707 :
34708 0 : static void dcerpc_Opnum148NotUsedOnWire_done(struct tevent_req *subreq)
34709 : {
34710 0 : struct tevent_req *req = tevent_req_callback_data(
34711 : subreq, struct tevent_req);
34712 0 : struct dcerpc_Opnum148NotUsedOnWire_state *state = tevent_req_data(
34713 : req, struct dcerpc_Opnum148NotUsedOnWire_state);
34714 : NTSTATUS status;
34715 : TALLOC_CTX *mem_ctx;
34716 :
34717 0 : if (state->out_mem_ctx) {
34718 0 : mem_ctx = state->out_mem_ctx;
34719 : } else {
34720 0 : mem_ctx = state;
34721 : }
34722 :
34723 0 : status = dcerpc_Opnum148NotUsedOnWire_r_recv(subreq, mem_ctx);
34724 0 : TALLOC_FREE(subreq);
34725 0 : if (tevent_req_nterror(req, status)) {
34726 0 : return;
34727 : }
34728 :
34729 : /* Copy out parameters */
34730 :
34731 : /* Copy result */
34732 0 : state->orig.out.result = state->tmp.out.result;
34733 :
34734 : /* Reset temporary structure */
34735 0 : NDR_ZERO_STRUCT(state->tmp);
34736 :
34737 0 : tevent_req_done(req);
34738 : }
34739 :
34740 0 : NTSTATUS dcerpc_Opnum148NotUsedOnWire_recv(struct tevent_req *req,
34741 : TALLOC_CTX *mem_ctx,
34742 : WERROR *result)
34743 : {
34744 0 : struct dcerpc_Opnum148NotUsedOnWire_state *state = tevent_req_data(
34745 : req, struct dcerpc_Opnum148NotUsedOnWire_state);
34746 : NTSTATUS status;
34747 :
34748 0 : if (tevent_req_is_nterror(req, &status)) {
34749 0 : tevent_req_received(req);
34750 0 : return status;
34751 : }
34752 :
34753 : /* Steal possible out parameters to the callers context */
34754 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34755 :
34756 : /* Return result */
34757 0 : *result = state->orig.out.result;
34758 :
34759 0 : tevent_req_received(req);
34760 0 : return NT_STATUS_OK;
34761 : }
34762 :
34763 0 : NTSTATUS dcerpc_Opnum148NotUsedOnWire(struct dcerpc_binding_handle *h,
34764 : TALLOC_CTX *mem_ctx,
34765 : WERROR *result)
34766 : {
34767 : struct Opnum148NotUsedOnWire r;
34768 : NTSTATUS status;
34769 :
34770 : /* In parameters */
34771 :
34772 : /* Out parameters */
34773 :
34774 : /* Result */
34775 0 : NDR_ZERO_STRUCT(r.out.result);
34776 :
34777 0 : status = dcerpc_Opnum148NotUsedOnWire_r(h, mem_ctx, &r);
34778 0 : if (!NT_STATUS_IS_OK(status)) {
34779 0 : return status;
34780 : }
34781 :
34782 : /* Return variables */
34783 :
34784 : /* Return result */
34785 0 : *result = r.out.result;
34786 :
34787 0 : return NT_STATUS_OK;
34788 : }
34789 :
34790 : struct dcerpc_Opnum149otUsedOnWire_r_state {
34791 : TALLOC_CTX *out_mem_ctx;
34792 : };
34793 :
34794 : static void dcerpc_Opnum149otUsedOnWire_r_done(struct tevent_req *subreq);
34795 :
34796 0 : struct tevent_req *dcerpc_Opnum149otUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
34797 : struct tevent_context *ev,
34798 : struct dcerpc_binding_handle *h,
34799 : struct Opnum149otUsedOnWire *r)
34800 : {
34801 : struct tevent_req *req;
34802 : struct dcerpc_Opnum149otUsedOnWire_r_state *state;
34803 : struct tevent_req *subreq;
34804 :
34805 0 : req = tevent_req_create(mem_ctx, &state,
34806 : struct dcerpc_Opnum149otUsedOnWire_r_state);
34807 0 : if (req == NULL) {
34808 0 : return NULL;
34809 : }
34810 :
34811 0 : state->out_mem_ctx = NULL;
34812 :
34813 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
34814 : NULL, &ndr_table_clusapi,
34815 : NDR_OPNUM149OTUSEDONWIRE, state, r);
34816 0 : if (tevent_req_nomem(subreq, req)) {
34817 0 : return tevent_req_post(req, ev);
34818 : }
34819 0 : tevent_req_set_callback(subreq, dcerpc_Opnum149otUsedOnWire_r_done, req);
34820 :
34821 0 : return req;
34822 : }
34823 :
34824 0 : static void dcerpc_Opnum149otUsedOnWire_r_done(struct tevent_req *subreq)
34825 : {
34826 0 : struct tevent_req *req =
34827 0 : tevent_req_callback_data(subreq,
34828 : struct tevent_req);
34829 : NTSTATUS status;
34830 :
34831 0 : status = dcerpc_binding_handle_call_recv(subreq);
34832 0 : TALLOC_FREE(subreq);
34833 0 : if (tevent_req_nterror(req, status)) {
34834 0 : return;
34835 : }
34836 :
34837 0 : tevent_req_done(req);
34838 : }
34839 :
34840 0 : NTSTATUS dcerpc_Opnum149otUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
34841 : {
34842 0 : struct dcerpc_Opnum149otUsedOnWire_r_state *state =
34843 0 : tevent_req_data(req,
34844 : struct dcerpc_Opnum149otUsedOnWire_r_state);
34845 : NTSTATUS status;
34846 :
34847 0 : if (tevent_req_is_nterror(req, &status)) {
34848 0 : tevent_req_received(req);
34849 0 : return status;
34850 : }
34851 :
34852 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34853 :
34854 0 : tevent_req_received(req);
34855 0 : return NT_STATUS_OK;
34856 : }
34857 :
34858 0 : NTSTATUS dcerpc_Opnum149otUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum149otUsedOnWire *r)
34859 : {
34860 : NTSTATUS status;
34861 :
34862 0 : status = dcerpc_binding_handle_call(h,
34863 : NULL, &ndr_table_clusapi,
34864 : NDR_OPNUM149OTUSEDONWIRE, mem_ctx, r);
34865 :
34866 0 : return status;
34867 : }
34868 :
34869 : struct dcerpc_Opnum149otUsedOnWire_state {
34870 : struct Opnum149otUsedOnWire orig;
34871 : struct Opnum149otUsedOnWire tmp;
34872 : TALLOC_CTX *out_mem_ctx;
34873 : };
34874 :
34875 : static void dcerpc_Opnum149otUsedOnWire_done(struct tevent_req *subreq);
34876 :
34877 0 : struct tevent_req *dcerpc_Opnum149otUsedOnWire_send(TALLOC_CTX *mem_ctx,
34878 : struct tevent_context *ev,
34879 : struct dcerpc_binding_handle *h)
34880 : {
34881 : struct tevent_req *req;
34882 : struct dcerpc_Opnum149otUsedOnWire_state *state;
34883 : struct tevent_req *subreq;
34884 :
34885 0 : req = tevent_req_create(mem_ctx, &state,
34886 : struct dcerpc_Opnum149otUsedOnWire_state);
34887 0 : if (req == NULL) {
34888 0 : return NULL;
34889 : }
34890 0 : state->out_mem_ctx = NULL;
34891 :
34892 : /* In parameters */
34893 :
34894 : /* Out parameters */
34895 :
34896 : /* Result */
34897 0 : NDR_ZERO_STRUCT(state->orig.out.result);
34898 :
34899 : /* make a temporary copy, that we pass to the dispatch function */
34900 0 : state->tmp = state->orig;
34901 :
34902 0 : subreq = dcerpc_Opnum149otUsedOnWire_r_send(state, ev, h, &state->tmp);
34903 0 : if (tevent_req_nomem(subreq, req)) {
34904 0 : return tevent_req_post(req, ev);
34905 : }
34906 0 : tevent_req_set_callback(subreq, dcerpc_Opnum149otUsedOnWire_done, req);
34907 0 : return req;
34908 : }
34909 :
34910 0 : static void dcerpc_Opnum149otUsedOnWire_done(struct tevent_req *subreq)
34911 : {
34912 0 : struct tevent_req *req = tevent_req_callback_data(
34913 : subreq, struct tevent_req);
34914 0 : struct dcerpc_Opnum149otUsedOnWire_state *state = tevent_req_data(
34915 : req, struct dcerpc_Opnum149otUsedOnWire_state);
34916 : NTSTATUS status;
34917 : TALLOC_CTX *mem_ctx;
34918 :
34919 0 : if (state->out_mem_ctx) {
34920 0 : mem_ctx = state->out_mem_ctx;
34921 : } else {
34922 0 : mem_ctx = state;
34923 : }
34924 :
34925 0 : status = dcerpc_Opnum149otUsedOnWire_r_recv(subreq, mem_ctx);
34926 0 : TALLOC_FREE(subreq);
34927 0 : if (tevent_req_nterror(req, status)) {
34928 0 : return;
34929 : }
34930 :
34931 : /* Copy out parameters */
34932 :
34933 : /* Copy result */
34934 0 : state->orig.out.result = state->tmp.out.result;
34935 :
34936 : /* Reset temporary structure */
34937 0 : NDR_ZERO_STRUCT(state->tmp);
34938 :
34939 0 : tevent_req_done(req);
34940 : }
34941 :
34942 0 : NTSTATUS dcerpc_Opnum149otUsedOnWire_recv(struct tevent_req *req,
34943 : TALLOC_CTX *mem_ctx,
34944 : WERROR *result)
34945 : {
34946 0 : struct dcerpc_Opnum149otUsedOnWire_state *state = tevent_req_data(
34947 : req, struct dcerpc_Opnum149otUsedOnWire_state);
34948 : NTSTATUS status;
34949 :
34950 0 : if (tevent_req_is_nterror(req, &status)) {
34951 0 : tevent_req_received(req);
34952 0 : return status;
34953 : }
34954 :
34955 : /* Steal possible out parameters to the callers context */
34956 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
34957 :
34958 : /* Return result */
34959 0 : *result = state->orig.out.result;
34960 :
34961 0 : tevent_req_received(req);
34962 0 : return NT_STATUS_OK;
34963 : }
34964 :
34965 0 : NTSTATUS dcerpc_Opnum149otUsedOnWire(struct dcerpc_binding_handle *h,
34966 : TALLOC_CTX *mem_ctx,
34967 : WERROR *result)
34968 : {
34969 : struct Opnum149otUsedOnWire r;
34970 : NTSTATUS status;
34971 :
34972 : /* In parameters */
34973 :
34974 : /* Out parameters */
34975 :
34976 : /* Result */
34977 0 : NDR_ZERO_STRUCT(r.out.result);
34978 :
34979 0 : status = dcerpc_Opnum149otUsedOnWire_r(h, mem_ctx, &r);
34980 0 : if (!NT_STATUS_IS_OK(status)) {
34981 0 : return status;
34982 : }
34983 :
34984 : /* Return variables */
34985 :
34986 : /* Return result */
34987 0 : *result = r.out.result;
34988 :
34989 0 : return NT_STATUS_OK;
34990 : }
34991 :
34992 : struct dcerpc_Opnum150NotUsedOnWire_r_state {
34993 : TALLOC_CTX *out_mem_ctx;
34994 : };
34995 :
34996 : static void dcerpc_Opnum150NotUsedOnWire_r_done(struct tevent_req *subreq);
34997 :
34998 0 : struct tevent_req *dcerpc_Opnum150NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
34999 : struct tevent_context *ev,
35000 : struct dcerpc_binding_handle *h,
35001 : struct Opnum150NotUsedOnWire *r)
35002 : {
35003 : struct tevent_req *req;
35004 : struct dcerpc_Opnum150NotUsedOnWire_r_state *state;
35005 : struct tevent_req *subreq;
35006 :
35007 0 : req = tevent_req_create(mem_ctx, &state,
35008 : struct dcerpc_Opnum150NotUsedOnWire_r_state);
35009 0 : if (req == NULL) {
35010 0 : return NULL;
35011 : }
35012 :
35013 0 : state->out_mem_ctx = NULL;
35014 :
35015 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
35016 : NULL, &ndr_table_clusapi,
35017 : NDR_OPNUM150NOTUSEDONWIRE, state, r);
35018 0 : if (tevent_req_nomem(subreq, req)) {
35019 0 : return tevent_req_post(req, ev);
35020 : }
35021 0 : tevent_req_set_callback(subreq, dcerpc_Opnum150NotUsedOnWire_r_done, req);
35022 :
35023 0 : return req;
35024 : }
35025 :
35026 0 : static void dcerpc_Opnum150NotUsedOnWire_r_done(struct tevent_req *subreq)
35027 : {
35028 0 : struct tevent_req *req =
35029 0 : tevent_req_callback_data(subreq,
35030 : struct tevent_req);
35031 : NTSTATUS status;
35032 :
35033 0 : status = dcerpc_binding_handle_call_recv(subreq);
35034 0 : TALLOC_FREE(subreq);
35035 0 : if (tevent_req_nterror(req, status)) {
35036 0 : return;
35037 : }
35038 :
35039 0 : tevent_req_done(req);
35040 : }
35041 :
35042 0 : NTSTATUS dcerpc_Opnum150NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
35043 : {
35044 0 : struct dcerpc_Opnum150NotUsedOnWire_r_state *state =
35045 0 : tevent_req_data(req,
35046 : struct dcerpc_Opnum150NotUsedOnWire_r_state);
35047 : NTSTATUS status;
35048 :
35049 0 : if (tevent_req_is_nterror(req, &status)) {
35050 0 : tevent_req_received(req);
35051 0 : return status;
35052 : }
35053 :
35054 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35055 :
35056 0 : tevent_req_received(req);
35057 0 : return NT_STATUS_OK;
35058 : }
35059 :
35060 0 : NTSTATUS dcerpc_Opnum150NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum150NotUsedOnWire *r)
35061 : {
35062 : NTSTATUS status;
35063 :
35064 0 : status = dcerpc_binding_handle_call(h,
35065 : NULL, &ndr_table_clusapi,
35066 : NDR_OPNUM150NOTUSEDONWIRE, mem_ctx, r);
35067 :
35068 0 : return status;
35069 : }
35070 :
35071 : struct dcerpc_Opnum150NotUsedOnWire_state {
35072 : struct Opnum150NotUsedOnWire orig;
35073 : struct Opnum150NotUsedOnWire tmp;
35074 : TALLOC_CTX *out_mem_ctx;
35075 : };
35076 :
35077 : static void dcerpc_Opnum150NotUsedOnWire_done(struct tevent_req *subreq);
35078 :
35079 0 : struct tevent_req *dcerpc_Opnum150NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
35080 : struct tevent_context *ev,
35081 : struct dcerpc_binding_handle *h)
35082 : {
35083 : struct tevent_req *req;
35084 : struct dcerpc_Opnum150NotUsedOnWire_state *state;
35085 : struct tevent_req *subreq;
35086 :
35087 0 : req = tevent_req_create(mem_ctx, &state,
35088 : struct dcerpc_Opnum150NotUsedOnWire_state);
35089 0 : if (req == NULL) {
35090 0 : return NULL;
35091 : }
35092 0 : state->out_mem_ctx = NULL;
35093 :
35094 : /* In parameters */
35095 :
35096 : /* Out parameters */
35097 :
35098 : /* Result */
35099 0 : NDR_ZERO_STRUCT(state->orig.out.result);
35100 :
35101 : /* make a temporary copy, that we pass to the dispatch function */
35102 0 : state->tmp = state->orig;
35103 :
35104 0 : subreq = dcerpc_Opnum150NotUsedOnWire_r_send(state, ev, h, &state->tmp);
35105 0 : if (tevent_req_nomem(subreq, req)) {
35106 0 : return tevent_req_post(req, ev);
35107 : }
35108 0 : tevent_req_set_callback(subreq, dcerpc_Opnum150NotUsedOnWire_done, req);
35109 0 : return req;
35110 : }
35111 :
35112 0 : static void dcerpc_Opnum150NotUsedOnWire_done(struct tevent_req *subreq)
35113 : {
35114 0 : struct tevent_req *req = tevent_req_callback_data(
35115 : subreq, struct tevent_req);
35116 0 : struct dcerpc_Opnum150NotUsedOnWire_state *state = tevent_req_data(
35117 : req, struct dcerpc_Opnum150NotUsedOnWire_state);
35118 : NTSTATUS status;
35119 : TALLOC_CTX *mem_ctx;
35120 :
35121 0 : if (state->out_mem_ctx) {
35122 0 : mem_ctx = state->out_mem_ctx;
35123 : } else {
35124 0 : mem_ctx = state;
35125 : }
35126 :
35127 0 : status = dcerpc_Opnum150NotUsedOnWire_r_recv(subreq, mem_ctx);
35128 0 : TALLOC_FREE(subreq);
35129 0 : if (tevent_req_nterror(req, status)) {
35130 0 : return;
35131 : }
35132 :
35133 : /* Copy out parameters */
35134 :
35135 : /* Copy result */
35136 0 : state->orig.out.result = state->tmp.out.result;
35137 :
35138 : /* Reset temporary structure */
35139 0 : NDR_ZERO_STRUCT(state->tmp);
35140 :
35141 0 : tevent_req_done(req);
35142 : }
35143 :
35144 0 : NTSTATUS dcerpc_Opnum150NotUsedOnWire_recv(struct tevent_req *req,
35145 : TALLOC_CTX *mem_ctx,
35146 : WERROR *result)
35147 : {
35148 0 : struct dcerpc_Opnum150NotUsedOnWire_state *state = tevent_req_data(
35149 : req, struct dcerpc_Opnum150NotUsedOnWire_state);
35150 : NTSTATUS status;
35151 :
35152 0 : if (tevent_req_is_nterror(req, &status)) {
35153 0 : tevent_req_received(req);
35154 0 : return status;
35155 : }
35156 :
35157 : /* Steal possible out parameters to the callers context */
35158 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35159 :
35160 : /* Return result */
35161 0 : *result = state->orig.out.result;
35162 :
35163 0 : tevent_req_received(req);
35164 0 : return NT_STATUS_OK;
35165 : }
35166 :
35167 0 : NTSTATUS dcerpc_Opnum150NotUsedOnWire(struct dcerpc_binding_handle *h,
35168 : TALLOC_CTX *mem_ctx,
35169 : WERROR *result)
35170 : {
35171 : struct Opnum150NotUsedOnWire r;
35172 : NTSTATUS status;
35173 :
35174 : /* In parameters */
35175 :
35176 : /* Out parameters */
35177 :
35178 : /* Result */
35179 0 : NDR_ZERO_STRUCT(r.out.result);
35180 :
35181 0 : status = dcerpc_Opnum150NotUsedOnWire_r(h, mem_ctx, &r);
35182 0 : if (!NT_STATUS_IS_OK(status)) {
35183 0 : return status;
35184 : }
35185 :
35186 : /* Return variables */
35187 :
35188 : /* Return result */
35189 0 : *result = r.out.result;
35190 :
35191 0 : return NT_STATUS_OK;
35192 : }
35193 :
35194 : struct dcerpc_Opnum151NotUsedOnWire_r_state {
35195 : TALLOC_CTX *out_mem_ctx;
35196 : };
35197 :
35198 : static void dcerpc_Opnum151NotUsedOnWire_r_done(struct tevent_req *subreq);
35199 :
35200 0 : struct tevent_req *dcerpc_Opnum151NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
35201 : struct tevent_context *ev,
35202 : struct dcerpc_binding_handle *h,
35203 : struct Opnum151NotUsedOnWire *r)
35204 : {
35205 : struct tevent_req *req;
35206 : struct dcerpc_Opnum151NotUsedOnWire_r_state *state;
35207 : struct tevent_req *subreq;
35208 :
35209 0 : req = tevent_req_create(mem_ctx, &state,
35210 : struct dcerpc_Opnum151NotUsedOnWire_r_state);
35211 0 : if (req == NULL) {
35212 0 : return NULL;
35213 : }
35214 :
35215 0 : state->out_mem_ctx = NULL;
35216 :
35217 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
35218 : NULL, &ndr_table_clusapi,
35219 : NDR_OPNUM151NOTUSEDONWIRE, state, r);
35220 0 : if (tevent_req_nomem(subreq, req)) {
35221 0 : return tevent_req_post(req, ev);
35222 : }
35223 0 : tevent_req_set_callback(subreq, dcerpc_Opnum151NotUsedOnWire_r_done, req);
35224 :
35225 0 : return req;
35226 : }
35227 :
35228 0 : static void dcerpc_Opnum151NotUsedOnWire_r_done(struct tevent_req *subreq)
35229 : {
35230 0 : struct tevent_req *req =
35231 0 : tevent_req_callback_data(subreq,
35232 : struct tevent_req);
35233 : NTSTATUS status;
35234 :
35235 0 : status = dcerpc_binding_handle_call_recv(subreq);
35236 0 : TALLOC_FREE(subreq);
35237 0 : if (tevent_req_nterror(req, status)) {
35238 0 : return;
35239 : }
35240 :
35241 0 : tevent_req_done(req);
35242 : }
35243 :
35244 0 : NTSTATUS dcerpc_Opnum151NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
35245 : {
35246 0 : struct dcerpc_Opnum151NotUsedOnWire_r_state *state =
35247 0 : tevent_req_data(req,
35248 : struct dcerpc_Opnum151NotUsedOnWire_r_state);
35249 : NTSTATUS status;
35250 :
35251 0 : if (tevent_req_is_nterror(req, &status)) {
35252 0 : tevent_req_received(req);
35253 0 : return status;
35254 : }
35255 :
35256 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35257 :
35258 0 : tevent_req_received(req);
35259 0 : return NT_STATUS_OK;
35260 : }
35261 :
35262 0 : NTSTATUS dcerpc_Opnum151NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum151NotUsedOnWire *r)
35263 : {
35264 : NTSTATUS status;
35265 :
35266 0 : status = dcerpc_binding_handle_call(h,
35267 : NULL, &ndr_table_clusapi,
35268 : NDR_OPNUM151NOTUSEDONWIRE, mem_ctx, r);
35269 :
35270 0 : return status;
35271 : }
35272 :
35273 : struct dcerpc_Opnum151NotUsedOnWire_state {
35274 : struct Opnum151NotUsedOnWire orig;
35275 : struct Opnum151NotUsedOnWire tmp;
35276 : TALLOC_CTX *out_mem_ctx;
35277 : };
35278 :
35279 : static void dcerpc_Opnum151NotUsedOnWire_done(struct tevent_req *subreq);
35280 :
35281 0 : struct tevent_req *dcerpc_Opnum151NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
35282 : struct tevent_context *ev,
35283 : struct dcerpc_binding_handle *h)
35284 : {
35285 : struct tevent_req *req;
35286 : struct dcerpc_Opnum151NotUsedOnWire_state *state;
35287 : struct tevent_req *subreq;
35288 :
35289 0 : req = tevent_req_create(mem_ctx, &state,
35290 : struct dcerpc_Opnum151NotUsedOnWire_state);
35291 0 : if (req == NULL) {
35292 0 : return NULL;
35293 : }
35294 0 : state->out_mem_ctx = NULL;
35295 :
35296 : /* In parameters */
35297 :
35298 : /* Out parameters */
35299 :
35300 : /* Result */
35301 0 : NDR_ZERO_STRUCT(state->orig.out.result);
35302 :
35303 : /* make a temporary copy, that we pass to the dispatch function */
35304 0 : state->tmp = state->orig;
35305 :
35306 0 : subreq = dcerpc_Opnum151NotUsedOnWire_r_send(state, ev, h, &state->tmp);
35307 0 : if (tevent_req_nomem(subreq, req)) {
35308 0 : return tevent_req_post(req, ev);
35309 : }
35310 0 : tevent_req_set_callback(subreq, dcerpc_Opnum151NotUsedOnWire_done, req);
35311 0 : return req;
35312 : }
35313 :
35314 0 : static void dcerpc_Opnum151NotUsedOnWire_done(struct tevent_req *subreq)
35315 : {
35316 0 : struct tevent_req *req = tevent_req_callback_data(
35317 : subreq, struct tevent_req);
35318 0 : struct dcerpc_Opnum151NotUsedOnWire_state *state = tevent_req_data(
35319 : req, struct dcerpc_Opnum151NotUsedOnWire_state);
35320 : NTSTATUS status;
35321 : TALLOC_CTX *mem_ctx;
35322 :
35323 0 : if (state->out_mem_ctx) {
35324 0 : mem_ctx = state->out_mem_ctx;
35325 : } else {
35326 0 : mem_ctx = state;
35327 : }
35328 :
35329 0 : status = dcerpc_Opnum151NotUsedOnWire_r_recv(subreq, mem_ctx);
35330 0 : TALLOC_FREE(subreq);
35331 0 : if (tevent_req_nterror(req, status)) {
35332 0 : return;
35333 : }
35334 :
35335 : /* Copy out parameters */
35336 :
35337 : /* Copy result */
35338 0 : state->orig.out.result = state->tmp.out.result;
35339 :
35340 : /* Reset temporary structure */
35341 0 : NDR_ZERO_STRUCT(state->tmp);
35342 :
35343 0 : tevent_req_done(req);
35344 : }
35345 :
35346 0 : NTSTATUS dcerpc_Opnum151NotUsedOnWire_recv(struct tevent_req *req,
35347 : TALLOC_CTX *mem_ctx,
35348 : WERROR *result)
35349 : {
35350 0 : struct dcerpc_Opnum151NotUsedOnWire_state *state = tevent_req_data(
35351 : req, struct dcerpc_Opnum151NotUsedOnWire_state);
35352 : NTSTATUS status;
35353 :
35354 0 : if (tevent_req_is_nterror(req, &status)) {
35355 0 : tevent_req_received(req);
35356 0 : return status;
35357 : }
35358 :
35359 : /* Steal possible out parameters to the callers context */
35360 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35361 :
35362 : /* Return result */
35363 0 : *result = state->orig.out.result;
35364 :
35365 0 : tevent_req_received(req);
35366 0 : return NT_STATUS_OK;
35367 : }
35368 :
35369 0 : NTSTATUS dcerpc_Opnum151NotUsedOnWire(struct dcerpc_binding_handle *h,
35370 : TALLOC_CTX *mem_ctx,
35371 : WERROR *result)
35372 : {
35373 : struct Opnum151NotUsedOnWire r;
35374 : NTSTATUS status;
35375 :
35376 : /* In parameters */
35377 :
35378 : /* Out parameters */
35379 :
35380 : /* Result */
35381 0 : NDR_ZERO_STRUCT(r.out.result);
35382 :
35383 0 : status = dcerpc_Opnum151NotUsedOnWire_r(h, mem_ctx, &r);
35384 0 : if (!NT_STATUS_IS_OK(status)) {
35385 0 : return status;
35386 : }
35387 :
35388 : /* Return variables */
35389 :
35390 : /* Return result */
35391 0 : *result = r.out.result;
35392 :
35393 0 : return NT_STATUS_OK;
35394 : }
35395 :
35396 : struct dcerpc_Opnum152NotUsedOnWire_r_state {
35397 : TALLOC_CTX *out_mem_ctx;
35398 : };
35399 :
35400 : static void dcerpc_Opnum152NotUsedOnWire_r_done(struct tevent_req *subreq);
35401 :
35402 0 : struct tevent_req *dcerpc_Opnum152NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
35403 : struct tevent_context *ev,
35404 : struct dcerpc_binding_handle *h,
35405 : struct Opnum152NotUsedOnWire *r)
35406 : {
35407 : struct tevent_req *req;
35408 : struct dcerpc_Opnum152NotUsedOnWire_r_state *state;
35409 : struct tevent_req *subreq;
35410 :
35411 0 : req = tevent_req_create(mem_ctx, &state,
35412 : struct dcerpc_Opnum152NotUsedOnWire_r_state);
35413 0 : if (req == NULL) {
35414 0 : return NULL;
35415 : }
35416 :
35417 0 : state->out_mem_ctx = NULL;
35418 :
35419 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
35420 : NULL, &ndr_table_clusapi,
35421 : NDR_OPNUM152NOTUSEDONWIRE, state, r);
35422 0 : if (tevent_req_nomem(subreq, req)) {
35423 0 : return tevent_req_post(req, ev);
35424 : }
35425 0 : tevent_req_set_callback(subreq, dcerpc_Opnum152NotUsedOnWire_r_done, req);
35426 :
35427 0 : return req;
35428 : }
35429 :
35430 0 : static void dcerpc_Opnum152NotUsedOnWire_r_done(struct tevent_req *subreq)
35431 : {
35432 0 : struct tevent_req *req =
35433 0 : tevent_req_callback_data(subreq,
35434 : struct tevent_req);
35435 : NTSTATUS status;
35436 :
35437 0 : status = dcerpc_binding_handle_call_recv(subreq);
35438 0 : TALLOC_FREE(subreq);
35439 0 : if (tevent_req_nterror(req, status)) {
35440 0 : return;
35441 : }
35442 :
35443 0 : tevent_req_done(req);
35444 : }
35445 :
35446 0 : NTSTATUS dcerpc_Opnum152NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
35447 : {
35448 0 : struct dcerpc_Opnum152NotUsedOnWire_r_state *state =
35449 0 : tevent_req_data(req,
35450 : struct dcerpc_Opnum152NotUsedOnWire_r_state);
35451 : NTSTATUS status;
35452 :
35453 0 : if (tevent_req_is_nterror(req, &status)) {
35454 0 : tevent_req_received(req);
35455 0 : return status;
35456 : }
35457 :
35458 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35459 :
35460 0 : tevent_req_received(req);
35461 0 : return NT_STATUS_OK;
35462 : }
35463 :
35464 0 : NTSTATUS dcerpc_Opnum152NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum152NotUsedOnWire *r)
35465 : {
35466 : NTSTATUS status;
35467 :
35468 0 : status = dcerpc_binding_handle_call(h,
35469 : NULL, &ndr_table_clusapi,
35470 : NDR_OPNUM152NOTUSEDONWIRE, mem_ctx, r);
35471 :
35472 0 : return status;
35473 : }
35474 :
35475 : struct dcerpc_Opnum152NotUsedOnWire_state {
35476 : struct Opnum152NotUsedOnWire orig;
35477 : struct Opnum152NotUsedOnWire tmp;
35478 : TALLOC_CTX *out_mem_ctx;
35479 : };
35480 :
35481 : static void dcerpc_Opnum152NotUsedOnWire_done(struct tevent_req *subreq);
35482 :
35483 0 : struct tevent_req *dcerpc_Opnum152NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
35484 : struct tevent_context *ev,
35485 : struct dcerpc_binding_handle *h)
35486 : {
35487 : struct tevent_req *req;
35488 : struct dcerpc_Opnum152NotUsedOnWire_state *state;
35489 : struct tevent_req *subreq;
35490 :
35491 0 : req = tevent_req_create(mem_ctx, &state,
35492 : struct dcerpc_Opnum152NotUsedOnWire_state);
35493 0 : if (req == NULL) {
35494 0 : return NULL;
35495 : }
35496 0 : state->out_mem_ctx = NULL;
35497 :
35498 : /* In parameters */
35499 :
35500 : /* Out parameters */
35501 :
35502 : /* Result */
35503 0 : NDR_ZERO_STRUCT(state->orig.out.result);
35504 :
35505 : /* make a temporary copy, that we pass to the dispatch function */
35506 0 : state->tmp = state->orig;
35507 :
35508 0 : subreq = dcerpc_Opnum152NotUsedOnWire_r_send(state, ev, h, &state->tmp);
35509 0 : if (tevent_req_nomem(subreq, req)) {
35510 0 : return tevent_req_post(req, ev);
35511 : }
35512 0 : tevent_req_set_callback(subreq, dcerpc_Opnum152NotUsedOnWire_done, req);
35513 0 : return req;
35514 : }
35515 :
35516 0 : static void dcerpc_Opnum152NotUsedOnWire_done(struct tevent_req *subreq)
35517 : {
35518 0 : struct tevent_req *req = tevent_req_callback_data(
35519 : subreq, struct tevent_req);
35520 0 : struct dcerpc_Opnum152NotUsedOnWire_state *state = tevent_req_data(
35521 : req, struct dcerpc_Opnum152NotUsedOnWire_state);
35522 : NTSTATUS status;
35523 : TALLOC_CTX *mem_ctx;
35524 :
35525 0 : if (state->out_mem_ctx) {
35526 0 : mem_ctx = state->out_mem_ctx;
35527 : } else {
35528 0 : mem_ctx = state;
35529 : }
35530 :
35531 0 : status = dcerpc_Opnum152NotUsedOnWire_r_recv(subreq, mem_ctx);
35532 0 : TALLOC_FREE(subreq);
35533 0 : if (tevent_req_nterror(req, status)) {
35534 0 : return;
35535 : }
35536 :
35537 : /* Copy out parameters */
35538 :
35539 : /* Copy result */
35540 0 : state->orig.out.result = state->tmp.out.result;
35541 :
35542 : /* Reset temporary structure */
35543 0 : NDR_ZERO_STRUCT(state->tmp);
35544 :
35545 0 : tevent_req_done(req);
35546 : }
35547 :
35548 0 : NTSTATUS dcerpc_Opnum152NotUsedOnWire_recv(struct tevent_req *req,
35549 : TALLOC_CTX *mem_ctx,
35550 : WERROR *result)
35551 : {
35552 0 : struct dcerpc_Opnum152NotUsedOnWire_state *state = tevent_req_data(
35553 : req, struct dcerpc_Opnum152NotUsedOnWire_state);
35554 : NTSTATUS status;
35555 :
35556 0 : if (tevent_req_is_nterror(req, &status)) {
35557 0 : tevent_req_received(req);
35558 0 : return status;
35559 : }
35560 :
35561 : /* Steal possible out parameters to the callers context */
35562 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35563 :
35564 : /* Return result */
35565 0 : *result = state->orig.out.result;
35566 :
35567 0 : tevent_req_received(req);
35568 0 : return NT_STATUS_OK;
35569 : }
35570 :
35571 0 : NTSTATUS dcerpc_Opnum152NotUsedOnWire(struct dcerpc_binding_handle *h,
35572 : TALLOC_CTX *mem_ctx,
35573 : WERROR *result)
35574 : {
35575 : struct Opnum152NotUsedOnWire r;
35576 : NTSTATUS status;
35577 :
35578 : /* In parameters */
35579 :
35580 : /* Out parameters */
35581 :
35582 : /* Result */
35583 0 : NDR_ZERO_STRUCT(r.out.result);
35584 :
35585 0 : status = dcerpc_Opnum152NotUsedOnWire_r(h, mem_ctx, &r);
35586 0 : if (!NT_STATUS_IS_OK(status)) {
35587 0 : return status;
35588 : }
35589 :
35590 : /* Return variables */
35591 :
35592 : /* Return result */
35593 0 : *result = r.out.result;
35594 :
35595 0 : return NT_STATUS_OK;
35596 : }
35597 :
35598 : struct dcerpc_Opnum153NotUsedOnWire_r_state {
35599 : TALLOC_CTX *out_mem_ctx;
35600 : };
35601 :
35602 : static void dcerpc_Opnum153NotUsedOnWire_r_done(struct tevent_req *subreq);
35603 :
35604 0 : struct tevent_req *dcerpc_Opnum153NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
35605 : struct tevent_context *ev,
35606 : struct dcerpc_binding_handle *h,
35607 : struct Opnum153NotUsedOnWire *r)
35608 : {
35609 : struct tevent_req *req;
35610 : struct dcerpc_Opnum153NotUsedOnWire_r_state *state;
35611 : struct tevent_req *subreq;
35612 :
35613 0 : req = tevent_req_create(mem_ctx, &state,
35614 : struct dcerpc_Opnum153NotUsedOnWire_r_state);
35615 0 : if (req == NULL) {
35616 0 : return NULL;
35617 : }
35618 :
35619 0 : state->out_mem_ctx = NULL;
35620 :
35621 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
35622 : NULL, &ndr_table_clusapi,
35623 : NDR_OPNUM153NOTUSEDONWIRE, state, r);
35624 0 : if (tevent_req_nomem(subreq, req)) {
35625 0 : return tevent_req_post(req, ev);
35626 : }
35627 0 : tevent_req_set_callback(subreq, dcerpc_Opnum153NotUsedOnWire_r_done, req);
35628 :
35629 0 : return req;
35630 : }
35631 :
35632 0 : static void dcerpc_Opnum153NotUsedOnWire_r_done(struct tevent_req *subreq)
35633 : {
35634 0 : struct tevent_req *req =
35635 0 : tevent_req_callback_data(subreq,
35636 : struct tevent_req);
35637 : NTSTATUS status;
35638 :
35639 0 : status = dcerpc_binding_handle_call_recv(subreq);
35640 0 : TALLOC_FREE(subreq);
35641 0 : if (tevent_req_nterror(req, status)) {
35642 0 : return;
35643 : }
35644 :
35645 0 : tevent_req_done(req);
35646 : }
35647 :
35648 0 : NTSTATUS dcerpc_Opnum153NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
35649 : {
35650 0 : struct dcerpc_Opnum153NotUsedOnWire_r_state *state =
35651 0 : tevent_req_data(req,
35652 : struct dcerpc_Opnum153NotUsedOnWire_r_state);
35653 : NTSTATUS status;
35654 :
35655 0 : if (tevent_req_is_nterror(req, &status)) {
35656 0 : tevent_req_received(req);
35657 0 : return status;
35658 : }
35659 :
35660 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35661 :
35662 0 : tevent_req_received(req);
35663 0 : return NT_STATUS_OK;
35664 : }
35665 :
35666 0 : NTSTATUS dcerpc_Opnum153NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum153NotUsedOnWire *r)
35667 : {
35668 : NTSTATUS status;
35669 :
35670 0 : status = dcerpc_binding_handle_call(h,
35671 : NULL, &ndr_table_clusapi,
35672 : NDR_OPNUM153NOTUSEDONWIRE, mem_ctx, r);
35673 :
35674 0 : return status;
35675 : }
35676 :
35677 : struct dcerpc_Opnum153NotUsedOnWire_state {
35678 : struct Opnum153NotUsedOnWire orig;
35679 : struct Opnum153NotUsedOnWire tmp;
35680 : TALLOC_CTX *out_mem_ctx;
35681 : };
35682 :
35683 : static void dcerpc_Opnum153NotUsedOnWire_done(struct tevent_req *subreq);
35684 :
35685 0 : struct tevent_req *dcerpc_Opnum153NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
35686 : struct tevent_context *ev,
35687 : struct dcerpc_binding_handle *h)
35688 : {
35689 : struct tevent_req *req;
35690 : struct dcerpc_Opnum153NotUsedOnWire_state *state;
35691 : struct tevent_req *subreq;
35692 :
35693 0 : req = tevent_req_create(mem_ctx, &state,
35694 : struct dcerpc_Opnum153NotUsedOnWire_state);
35695 0 : if (req == NULL) {
35696 0 : return NULL;
35697 : }
35698 0 : state->out_mem_ctx = NULL;
35699 :
35700 : /* In parameters */
35701 :
35702 : /* Out parameters */
35703 :
35704 : /* Result */
35705 0 : NDR_ZERO_STRUCT(state->orig.out.result);
35706 :
35707 : /* make a temporary copy, that we pass to the dispatch function */
35708 0 : state->tmp = state->orig;
35709 :
35710 0 : subreq = dcerpc_Opnum153NotUsedOnWire_r_send(state, ev, h, &state->tmp);
35711 0 : if (tevent_req_nomem(subreq, req)) {
35712 0 : return tevent_req_post(req, ev);
35713 : }
35714 0 : tevent_req_set_callback(subreq, dcerpc_Opnum153NotUsedOnWire_done, req);
35715 0 : return req;
35716 : }
35717 :
35718 0 : static void dcerpc_Opnum153NotUsedOnWire_done(struct tevent_req *subreq)
35719 : {
35720 0 : struct tevent_req *req = tevent_req_callback_data(
35721 : subreq, struct tevent_req);
35722 0 : struct dcerpc_Opnum153NotUsedOnWire_state *state = tevent_req_data(
35723 : req, struct dcerpc_Opnum153NotUsedOnWire_state);
35724 : NTSTATUS status;
35725 : TALLOC_CTX *mem_ctx;
35726 :
35727 0 : if (state->out_mem_ctx) {
35728 0 : mem_ctx = state->out_mem_ctx;
35729 : } else {
35730 0 : mem_ctx = state;
35731 : }
35732 :
35733 0 : status = dcerpc_Opnum153NotUsedOnWire_r_recv(subreq, mem_ctx);
35734 0 : TALLOC_FREE(subreq);
35735 0 : if (tevent_req_nterror(req, status)) {
35736 0 : return;
35737 : }
35738 :
35739 : /* Copy out parameters */
35740 :
35741 : /* Copy result */
35742 0 : state->orig.out.result = state->tmp.out.result;
35743 :
35744 : /* Reset temporary structure */
35745 0 : NDR_ZERO_STRUCT(state->tmp);
35746 :
35747 0 : tevent_req_done(req);
35748 : }
35749 :
35750 0 : NTSTATUS dcerpc_Opnum153NotUsedOnWire_recv(struct tevent_req *req,
35751 : TALLOC_CTX *mem_ctx,
35752 : WERROR *result)
35753 : {
35754 0 : struct dcerpc_Opnum153NotUsedOnWire_state *state = tevent_req_data(
35755 : req, struct dcerpc_Opnum153NotUsedOnWire_state);
35756 : NTSTATUS status;
35757 :
35758 0 : if (tevent_req_is_nterror(req, &status)) {
35759 0 : tevent_req_received(req);
35760 0 : return status;
35761 : }
35762 :
35763 : /* Steal possible out parameters to the callers context */
35764 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35765 :
35766 : /* Return result */
35767 0 : *result = state->orig.out.result;
35768 :
35769 0 : tevent_req_received(req);
35770 0 : return NT_STATUS_OK;
35771 : }
35772 :
35773 0 : NTSTATUS dcerpc_Opnum153NotUsedOnWire(struct dcerpc_binding_handle *h,
35774 : TALLOC_CTX *mem_ctx,
35775 : WERROR *result)
35776 : {
35777 : struct Opnum153NotUsedOnWire r;
35778 : NTSTATUS status;
35779 :
35780 : /* In parameters */
35781 :
35782 : /* Out parameters */
35783 :
35784 : /* Result */
35785 0 : NDR_ZERO_STRUCT(r.out.result);
35786 :
35787 0 : status = dcerpc_Opnum153NotUsedOnWire_r(h, mem_ctx, &r);
35788 0 : if (!NT_STATUS_IS_OK(status)) {
35789 0 : return status;
35790 : }
35791 :
35792 : /* Return variables */
35793 :
35794 : /* Return result */
35795 0 : *result = r.out.result;
35796 :
35797 0 : return NT_STATUS_OK;
35798 : }
35799 :
35800 : struct dcerpc_Opnum154NotUsedOnWire_r_state {
35801 : TALLOC_CTX *out_mem_ctx;
35802 : };
35803 :
35804 : static void dcerpc_Opnum154NotUsedOnWire_r_done(struct tevent_req *subreq);
35805 :
35806 0 : struct tevent_req *dcerpc_Opnum154NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
35807 : struct tevent_context *ev,
35808 : struct dcerpc_binding_handle *h,
35809 : struct Opnum154NotUsedOnWire *r)
35810 : {
35811 : struct tevent_req *req;
35812 : struct dcerpc_Opnum154NotUsedOnWire_r_state *state;
35813 : struct tevent_req *subreq;
35814 :
35815 0 : req = tevent_req_create(mem_ctx, &state,
35816 : struct dcerpc_Opnum154NotUsedOnWire_r_state);
35817 0 : if (req == NULL) {
35818 0 : return NULL;
35819 : }
35820 :
35821 0 : state->out_mem_ctx = NULL;
35822 :
35823 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
35824 : NULL, &ndr_table_clusapi,
35825 : NDR_OPNUM154NOTUSEDONWIRE, state, r);
35826 0 : if (tevent_req_nomem(subreq, req)) {
35827 0 : return tevent_req_post(req, ev);
35828 : }
35829 0 : tevent_req_set_callback(subreq, dcerpc_Opnum154NotUsedOnWire_r_done, req);
35830 :
35831 0 : return req;
35832 : }
35833 :
35834 0 : static void dcerpc_Opnum154NotUsedOnWire_r_done(struct tevent_req *subreq)
35835 : {
35836 0 : struct tevent_req *req =
35837 0 : tevent_req_callback_data(subreq,
35838 : struct tevent_req);
35839 : NTSTATUS status;
35840 :
35841 0 : status = dcerpc_binding_handle_call_recv(subreq);
35842 0 : TALLOC_FREE(subreq);
35843 0 : if (tevent_req_nterror(req, status)) {
35844 0 : return;
35845 : }
35846 :
35847 0 : tevent_req_done(req);
35848 : }
35849 :
35850 0 : NTSTATUS dcerpc_Opnum154NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
35851 : {
35852 0 : struct dcerpc_Opnum154NotUsedOnWire_r_state *state =
35853 0 : tevent_req_data(req,
35854 : struct dcerpc_Opnum154NotUsedOnWire_r_state);
35855 : NTSTATUS status;
35856 :
35857 0 : if (tevent_req_is_nterror(req, &status)) {
35858 0 : tevent_req_received(req);
35859 0 : return status;
35860 : }
35861 :
35862 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35863 :
35864 0 : tevent_req_received(req);
35865 0 : return NT_STATUS_OK;
35866 : }
35867 :
35868 0 : NTSTATUS dcerpc_Opnum154NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum154NotUsedOnWire *r)
35869 : {
35870 : NTSTATUS status;
35871 :
35872 0 : status = dcerpc_binding_handle_call(h,
35873 : NULL, &ndr_table_clusapi,
35874 : NDR_OPNUM154NOTUSEDONWIRE, mem_ctx, r);
35875 :
35876 0 : return status;
35877 : }
35878 :
35879 : struct dcerpc_Opnum154NotUsedOnWire_state {
35880 : struct Opnum154NotUsedOnWire orig;
35881 : struct Opnum154NotUsedOnWire tmp;
35882 : TALLOC_CTX *out_mem_ctx;
35883 : };
35884 :
35885 : static void dcerpc_Opnum154NotUsedOnWire_done(struct tevent_req *subreq);
35886 :
35887 0 : struct tevent_req *dcerpc_Opnum154NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
35888 : struct tevent_context *ev,
35889 : struct dcerpc_binding_handle *h)
35890 : {
35891 : struct tevent_req *req;
35892 : struct dcerpc_Opnum154NotUsedOnWire_state *state;
35893 : struct tevent_req *subreq;
35894 :
35895 0 : req = tevent_req_create(mem_ctx, &state,
35896 : struct dcerpc_Opnum154NotUsedOnWire_state);
35897 0 : if (req == NULL) {
35898 0 : return NULL;
35899 : }
35900 0 : state->out_mem_ctx = NULL;
35901 :
35902 : /* In parameters */
35903 :
35904 : /* Out parameters */
35905 :
35906 : /* Result */
35907 0 : NDR_ZERO_STRUCT(state->orig.out.result);
35908 :
35909 : /* make a temporary copy, that we pass to the dispatch function */
35910 0 : state->tmp = state->orig;
35911 :
35912 0 : subreq = dcerpc_Opnum154NotUsedOnWire_r_send(state, ev, h, &state->tmp);
35913 0 : if (tevent_req_nomem(subreq, req)) {
35914 0 : return tevent_req_post(req, ev);
35915 : }
35916 0 : tevent_req_set_callback(subreq, dcerpc_Opnum154NotUsedOnWire_done, req);
35917 0 : return req;
35918 : }
35919 :
35920 0 : static void dcerpc_Opnum154NotUsedOnWire_done(struct tevent_req *subreq)
35921 : {
35922 0 : struct tevent_req *req = tevent_req_callback_data(
35923 : subreq, struct tevent_req);
35924 0 : struct dcerpc_Opnum154NotUsedOnWire_state *state = tevent_req_data(
35925 : req, struct dcerpc_Opnum154NotUsedOnWire_state);
35926 : NTSTATUS status;
35927 : TALLOC_CTX *mem_ctx;
35928 :
35929 0 : if (state->out_mem_ctx) {
35930 0 : mem_ctx = state->out_mem_ctx;
35931 : } else {
35932 0 : mem_ctx = state;
35933 : }
35934 :
35935 0 : status = dcerpc_Opnum154NotUsedOnWire_r_recv(subreq, mem_ctx);
35936 0 : TALLOC_FREE(subreq);
35937 0 : if (tevent_req_nterror(req, status)) {
35938 0 : return;
35939 : }
35940 :
35941 : /* Copy out parameters */
35942 :
35943 : /* Copy result */
35944 0 : state->orig.out.result = state->tmp.out.result;
35945 :
35946 : /* Reset temporary structure */
35947 0 : NDR_ZERO_STRUCT(state->tmp);
35948 :
35949 0 : tevent_req_done(req);
35950 : }
35951 :
35952 0 : NTSTATUS dcerpc_Opnum154NotUsedOnWire_recv(struct tevent_req *req,
35953 : TALLOC_CTX *mem_ctx,
35954 : WERROR *result)
35955 : {
35956 0 : struct dcerpc_Opnum154NotUsedOnWire_state *state = tevent_req_data(
35957 : req, struct dcerpc_Opnum154NotUsedOnWire_state);
35958 : NTSTATUS status;
35959 :
35960 0 : if (tevent_req_is_nterror(req, &status)) {
35961 0 : tevent_req_received(req);
35962 0 : return status;
35963 : }
35964 :
35965 : /* Steal possible out parameters to the callers context */
35966 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
35967 :
35968 : /* Return result */
35969 0 : *result = state->orig.out.result;
35970 :
35971 0 : tevent_req_received(req);
35972 0 : return NT_STATUS_OK;
35973 : }
35974 :
35975 0 : NTSTATUS dcerpc_Opnum154NotUsedOnWire(struct dcerpc_binding_handle *h,
35976 : TALLOC_CTX *mem_ctx,
35977 : WERROR *result)
35978 : {
35979 : struct Opnum154NotUsedOnWire r;
35980 : NTSTATUS status;
35981 :
35982 : /* In parameters */
35983 :
35984 : /* Out parameters */
35985 :
35986 : /* Result */
35987 0 : NDR_ZERO_STRUCT(r.out.result);
35988 :
35989 0 : status = dcerpc_Opnum154NotUsedOnWire_r(h, mem_ctx, &r);
35990 0 : if (!NT_STATUS_IS_OK(status)) {
35991 0 : return status;
35992 : }
35993 :
35994 : /* Return variables */
35995 :
35996 : /* Return result */
35997 0 : *result = r.out.result;
35998 :
35999 0 : return NT_STATUS_OK;
36000 : }
36001 :
36002 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_r_state {
36003 : TALLOC_CTX *out_mem_ctx;
36004 : };
36005 :
36006 : static void dcerpc_clusapi_AddNotifyResourceTypeV2_r_done(struct tevent_req *subreq);
36007 :
36008 0 : struct tevent_req *dcerpc_clusapi_AddNotifyResourceTypeV2_r_send(TALLOC_CTX *mem_ctx,
36009 : struct tevent_context *ev,
36010 : struct dcerpc_binding_handle *h,
36011 : struct clusapi_AddNotifyResourceTypeV2 *r)
36012 : {
36013 : struct tevent_req *req;
36014 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_r_state *state;
36015 : struct tevent_req *subreq;
36016 :
36017 0 : req = tevent_req_create(mem_ctx, &state,
36018 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_r_state);
36019 0 : if (req == NULL) {
36020 0 : return NULL;
36021 : }
36022 :
36023 0 : state->out_mem_ctx = talloc_new(state);
36024 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
36025 0 : return tevent_req_post(req, ev);
36026 : }
36027 :
36028 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
36029 : NULL, &ndr_table_clusapi,
36030 0 : NDR_CLUSAPI_ADDNOTIFYRESOURCETYPEV2, state->out_mem_ctx, r);
36031 0 : if (tevent_req_nomem(subreq, req)) {
36032 0 : return tevent_req_post(req, ev);
36033 : }
36034 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyResourceTypeV2_r_done, req);
36035 :
36036 0 : return req;
36037 : }
36038 :
36039 0 : static void dcerpc_clusapi_AddNotifyResourceTypeV2_r_done(struct tevent_req *subreq)
36040 : {
36041 0 : struct tevent_req *req =
36042 0 : tevent_req_callback_data(subreq,
36043 : struct tevent_req);
36044 : NTSTATUS status;
36045 :
36046 0 : status = dcerpc_binding_handle_call_recv(subreq);
36047 0 : TALLOC_FREE(subreq);
36048 0 : if (tevent_req_nterror(req, status)) {
36049 0 : return;
36050 : }
36051 :
36052 0 : tevent_req_done(req);
36053 : }
36054 :
36055 0 : NTSTATUS dcerpc_clusapi_AddNotifyResourceTypeV2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
36056 : {
36057 0 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_r_state *state =
36058 0 : tevent_req_data(req,
36059 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_r_state);
36060 : NTSTATUS status;
36061 :
36062 0 : if (tevent_req_is_nterror(req, &status)) {
36063 0 : tevent_req_received(req);
36064 0 : return status;
36065 : }
36066 :
36067 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36068 :
36069 0 : tevent_req_received(req);
36070 0 : return NT_STATUS_OK;
36071 : }
36072 :
36073 0 : NTSTATUS dcerpc_clusapi_AddNotifyResourceTypeV2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddNotifyResourceTypeV2 *r)
36074 : {
36075 : NTSTATUS status;
36076 :
36077 0 : status = dcerpc_binding_handle_call(h,
36078 : NULL, &ndr_table_clusapi,
36079 : NDR_CLUSAPI_ADDNOTIFYRESOURCETYPEV2, mem_ctx, r);
36080 :
36081 0 : return status;
36082 : }
36083 :
36084 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_state {
36085 : struct clusapi_AddNotifyResourceTypeV2 orig;
36086 : struct clusapi_AddNotifyResourceTypeV2 tmp;
36087 : TALLOC_CTX *out_mem_ctx;
36088 : };
36089 :
36090 : static void dcerpc_clusapi_AddNotifyResourceTypeV2_done(struct tevent_req *subreq);
36091 :
36092 0 : struct tevent_req *dcerpc_clusapi_AddNotifyResourceTypeV2_send(TALLOC_CTX *mem_ctx,
36093 : struct tevent_context *ev,
36094 : struct dcerpc_binding_handle *h,
36095 : struct policy_handle _hNotify /* [in] */,
36096 : uint64_t _filter /* [in] */,
36097 : uint32_t _dwNotifyKey /* [in] */,
36098 : const char *_resTypeName /* [in] [charset(UTF16),ref] */,
36099 : uint32_t _dwVersion /* [in] */,
36100 : WERROR *_rpc_status /* [out] [ref] */)
36101 : {
36102 : struct tevent_req *req;
36103 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_state *state;
36104 : struct tevent_req *subreq;
36105 :
36106 0 : req = tevent_req_create(mem_ctx, &state,
36107 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_state);
36108 0 : if (req == NULL) {
36109 0 : return NULL;
36110 : }
36111 0 : state->out_mem_ctx = NULL;
36112 :
36113 : /* In parameters */
36114 0 : state->orig.in.hNotify = _hNotify;
36115 0 : state->orig.in.filter = _filter;
36116 0 : state->orig.in.dwNotifyKey = _dwNotifyKey;
36117 0 : state->orig.in.resTypeName = _resTypeName;
36118 0 : state->orig.in.dwVersion = _dwVersion;
36119 :
36120 : /* Out parameters */
36121 0 : state->orig.out.rpc_status = _rpc_status;
36122 :
36123 : /* Result */
36124 0 : NDR_ZERO_STRUCT(state->orig.out.result);
36125 :
36126 0 : state->out_mem_ctx = talloc_named_const(state, 0,
36127 : "dcerpc_clusapi_AddNotifyResourceTypeV2_out_memory");
36128 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
36129 0 : return tevent_req_post(req, ev);
36130 : }
36131 :
36132 : /* make a temporary copy, that we pass to the dispatch function */
36133 0 : state->tmp = state->orig;
36134 :
36135 0 : subreq = dcerpc_clusapi_AddNotifyResourceTypeV2_r_send(state, ev, h, &state->tmp);
36136 0 : if (tevent_req_nomem(subreq, req)) {
36137 0 : return tevent_req_post(req, ev);
36138 : }
36139 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddNotifyResourceTypeV2_done, req);
36140 0 : return req;
36141 : }
36142 :
36143 0 : static void dcerpc_clusapi_AddNotifyResourceTypeV2_done(struct tevent_req *subreq)
36144 : {
36145 0 : struct tevent_req *req = tevent_req_callback_data(
36146 : subreq, struct tevent_req);
36147 0 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_state *state = tevent_req_data(
36148 : req, struct dcerpc_clusapi_AddNotifyResourceTypeV2_state);
36149 : NTSTATUS status;
36150 : TALLOC_CTX *mem_ctx;
36151 :
36152 0 : if (state->out_mem_ctx) {
36153 0 : mem_ctx = state->out_mem_ctx;
36154 : } else {
36155 0 : mem_ctx = state;
36156 : }
36157 :
36158 0 : status = dcerpc_clusapi_AddNotifyResourceTypeV2_r_recv(subreq, mem_ctx);
36159 0 : TALLOC_FREE(subreq);
36160 0 : if (tevent_req_nterror(req, status)) {
36161 0 : return;
36162 : }
36163 :
36164 : /* Copy out parameters */
36165 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
36166 :
36167 : /* Copy result */
36168 0 : state->orig.out.result = state->tmp.out.result;
36169 :
36170 : /* Reset temporary structure */
36171 0 : NDR_ZERO_STRUCT(state->tmp);
36172 :
36173 0 : tevent_req_done(req);
36174 : }
36175 :
36176 0 : NTSTATUS dcerpc_clusapi_AddNotifyResourceTypeV2_recv(struct tevent_req *req,
36177 : TALLOC_CTX *mem_ctx,
36178 : WERROR *result)
36179 : {
36180 0 : struct dcerpc_clusapi_AddNotifyResourceTypeV2_state *state = tevent_req_data(
36181 : req, struct dcerpc_clusapi_AddNotifyResourceTypeV2_state);
36182 : NTSTATUS status;
36183 :
36184 0 : if (tevent_req_is_nterror(req, &status)) {
36185 0 : tevent_req_received(req);
36186 0 : return status;
36187 : }
36188 :
36189 : /* Steal possible out parameters to the callers context */
36190 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36191 :
36192 : /* Return result */
36193 0 : *result = state->orig.out.result;
36194 :
36195 0 : tevent_req_received(req);
36196 0 : return NT_STATUS_OK;
36197 : }
36198 :
36199 0 : NTSTATUS dcerpc_clusapi_AddNotifyResourceTypeV2(struct dcerpc_binding_handle *h,
36200 : TALLOC_CTX *mem_ctx,
36201 : struct policy_handle _hNotify /* [in] */,
36202 : uint64_t _filter /* [in] */,
36203 : uint32_t _dwNotifyKey /* [in] */,
36204 : const char *_resTypeName /* [in] [charset(UTF16),ref] */,
36205 : uint32_t _dwVersion /* [in] */,
36206 : WERROR *_rpc_status /* [out] [ref] */,
36207 : WERROR *result)
36208 : {
36209 : struct clusapi_AddNotifyResourceTypeV2 r;
36210 : NTSTATUS status;
36211 :
36212 : /* In parameters */
36213 0 : r.in.hNotify = _hNotify;
36214 0 : r.in.filter = _filter;
36215 0 : r.in.dwNotifyKey = _dwNotifyKey;
36216 0 : r.in.resTypeName = _resTypeName;
36217 0 : r.in.dwVersion = _dwVersion;
36218 :
36219 : /* Out parameters */
36220 0 : r.out.rpc_status = _rpc_status;
36221 :
36222 : /* Result */
36223 0 : NDR_ZERO_STRUCT(r.out.result);
36224 :
36225 0 : status = dcerpc_clusapi_AddNotifyResourceTypeV2_r(h, mem_ctx, &r);
36226 0 : if (!NT_STATUS_IS_OK(status)) {
36227 0 : return status;
36228 : }
36229 :
36230 : /* Return variables */
36231 0 : *_rpc_status = *r.out.rpc_status;
36232 :
36233 : /* Return result */
36234 0 : *result = r.out.result;
36235 :
36236 0 : return NT_STATUS_OK;
36237 : }
36238 :
36239 : struct dcerpc_Opnum156NotUsedOnWire_r_state {
36240 : TALLOC_CTX *out_mem_ctx;
36241 : };
36242 :
36243 : static void dcerpc_Opnum156NotUsedOnWire_r_done(struct tevent_req *subreq);
36244 :
36245 0 : struct tevent_req *dcerpc_Opnum156NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
36246 : struct tevent_context *ev,
36247 : struct dcerpc_binding_handle *h,
36248 : struct Opnum156NotUsedOnWire *r)
36249 : {
36250 : struct tevent_req *req;
36251 : struct dcerpc_Opnum156NotUsedOnWire_r_state *state;
36252 : struct tevent_req *subreq;
36253 :
36254 0 : req = tevent_req_create(mem_ctx, &state,
36255 : struct dcerpc_Opnum156NotUsedOnWire_r_state);
36256 0 : if (req == NULL) {
36257 0 : return NULL;
36258 : }
36259 :
36260 0 : state->out_mem_ctx = NULL;
36261 :
36262 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
36263 : NULL, &ndr_table_clusapi,
36264 : NDR_OPNUM156NOTUSEDONWIRE, state, r);
36265 0 : if (tevent_req_nomem(subreq, req)) {
36266 0 : return tevent_req_post(req, ev);
36267 : }
36268 0 : tevent_req_set_callback(subreq, dcerpc_Opnum156NotUsedOnWire_r_done, req);
36269 :
36270 0 : return req;
36271 : }
36272 :
36273 0 : static void dcerpc_Opnum156NotUsedOnWire_r_done(struct tevent_req *subreq)
36274 : {
36275 0 : struct tevent_req *req =
36276 0 : tevent_req_callback_data(subreq,
36277 : struct tevent_req);
36278 : NTSTATUS status;
36279 :
36280 0 : status = dcerpc_binding_handle_call_recv(subreq);
36281 0 : TALLOC_FREE(subreq);
36282 0 : if (tevent_req_nterror(req, status)) {
36283 0 : return;
36284 : }
36285 :
36286 0 : tevent_req_done(req);
36287 : }
36288 :
36289 0 : NTSTATUS dcerpc_Opnum156NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
36290 : {
36291 0 : struct dcerpc_Opnum156NotUsedOnWire_r_state *state =
36292 0 : tevent_req_data(req,
36293 : struct dcerpc_Opnum156NotUsedOnWire_r_state);
36294 : NTSTATUS status;
36295 :
36296 0 : if (tevent_req_is_nterror(req, &status)) {
36297 0 : tevent_req_received(req);
36298 0 : return status;
36299 : }
36300 :
36301 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36302 :
36303 0 : tevent_req_received(req);
36304 0 : return NT_STATUS_OK;
36305 : }
36306 :
36307 0 : NTSTATUS dcerpc_Opnum156NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum156NotUsedOnWire *r)
36308 : {
36309 : NTSTATUS status;
36310 :
36311 0 : status = dcerpc_binding_handle_call(h,
36312 : NULL, &ndr_table_clusapi,
36313 : NDR_OPNUM156NOTUSEDONWIRE, mem_ctx, r);
36314 :
36315 0 : return status;
36316 : }
36317 :
36318 : struct dcerpc_Opnum156NotUsedOnWire_state {
36319 : struct Opnum156NotUsedOnWire orig;
36320 : struct Opnum156NotUsedOnWire tmp;
36321 : TALLOC_CTX *out_mem_ctx;
36322 : };
36323 :
36324 : static void dcerpc_Opnum156NotUsedOnWire_done(struct tevent_req *subreq);
36325 :
36326 0 : struct tevent_req *dcerpc_Opnum156NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
36327 : struct tevent_context *ev,
36328 : struct dcerpc_binding_handle *h)
36329 : {
36330 : struct tevent_req *req;
36331 : struct dcerpc_Opnum156NotUsedOnWire_state *state;
36332 : struct tevent_req *subreq;
36333 :
36334 0 : req = tevent_req_create(mem_ctx, &state,
36335 : struct dcerpc_Opnum156NotUsedOnWire_state);
36336 0 : if (req == NULL) {
36337 0 : return NULL;
36338 : }
36339 0 : state->out_mem_ctx = NULL;
36340 :
36341 : /* In parameters */
36342 :
36343 : /* Out parameters */
36344 :
36345 : /* Result */
36346 0 : NDR_ZERO_STRUCT(state->orig.out.result);
36347 :
36348 : /* make a temporary copy, that we pass to the dispatch function */
36349 0 : state->tmp = state->orig;
36350 :
36351 0 : subreq = dcerpc_Opnum156NotUsedOnWire_r_send(state, ev, h, &state->tmp);
36352 0 : if (tevent_req_nomem(subreq, req)) {
36353 0 : return tevent_req_post(req, ev);
36354 : }
36355 0 : tevent_req_set_callback(subreq, dcerpc_Opnum156NotUsedOnWire_done, req);
36356 0 : return req;
36357 : }
36358 :
36359 0 : static void dcerpc_Opnum156NotUsedOnWire_done(struct tevent_req *subreq)
36360 : {
36361 0 : struct tevent_req *req = tevent_req_callback_data(
36362 : subreq, struct tevent_req);
36363 0 : struct dcerpc_Opnum156NotUsedOnWire_state *state = tevent_req_data(
36364 : req, struct dcerpc_Opnum156NotUsedOnWire_state);
36365 : NTSTATUS status;
36366 : TALLOC_CTX *mem_ctx;
36367 :
36368 0 : if (state->out_mem_ctx) {
36369 0 : mem_ctx = state->out_mem_ctx;
36370 : } else {
36371 0 : mem_ctx = state;
36372 : }
36373 :
36374 0 : status = dcerpc_Opnum156NotUsedOnWire_r_recv(subreq, mem_ctx);
36375 0 : TALLOC_FREE(subreq);
36376 0 : if (tevent_req_nterror(req, status)) {
36377 0 : return;
36378 : }
36379 :
36380 : /* Copy out parameters */
36381 :
36382 : /* Copy result */
36383 0 : state->orig.out.result = state->tmp.out.result;
36384 :
36385 : /* Reset temporary structure */
36386 0 : NDR_ZERO_STRUCT(state->tmp);
36387 :
36388 0 : tevent_req_done(req);
36389 : }
36390 :
36391 0 : NTSTATUS dcerpc_Opnum156NotUsedOnWire_recv(struct tevent_req *req,
36392 : TALLOC_CTX *mem_ctx,
36393 : WERROR *result)
36394 : {
36395 0 : struct dcerpc_Opnum156NotUsedOnWire_state *state = tevent_req_data(
36396 : req, struct dcerpc_Opnum156NotUsedOnWire_state);
36397 : NTSTATUS status;
36398 :
36399 0 : if (tevent_req_is_nterror(req, &status)) {
36400 0 : tevent_req_received(req);
36401 0 : return status;
36402 : }
36403 :
36404 : /* Steal possible out parameters to the callers context */
36405 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36406 :
36407 : /* Return result */
36408 0 : *result = state->orig.out.result;
36409 :
36410 0 : tevent_req_received(req);
36411 0 : return NT_STATUS_OK;
36412 : }
36413 :
36414 0 : NTSTATUS dcerpc_Opnum156NotUsedOnWire(struct dcerpc_binding_handle *h,
36415 : TALLOC_CTX *mem_ctx,
36416 : WERROR *result)
36417 : {
36418 : struct Opnum156NotUsedOnWire r;
36419 : NTSTATUS status;
36420 :
36421 : /* In parameters */
36422 :
36423 : /* Out parameters */
36424 :
36425 : /* Result */
36426 0 : NDR_ZERO_STRUCT(r.out.result);
36427 :
36428 0 : status = dcerpc_Opnum156NotUsedOnWire_r(h, mem_ctx, &r);
36429 0 : if (!NT_STATUS_IS_OK(status)) {
36430 0 : return status;
36431 : }
36432 :
36433 : /* Return variables */
36434 :
36435 : /* Return result */
36436 0 : *result = r.out.result;
36437 :
36438 0 : return NT_STATUS_OK;
36439 : }
36440 :
36441 : struct dcerpc_clusapi_ExecuteReadBatchEx_r_state {
36442 : TALLOC_CTX *out_mem_ctx;
36443 : };
36444 :
36445 : static void dcerpc_clusapi_ExecuteReadBatchEx_r_done(struct tevent_req *subreq);
36446 :
36447 0 : struct tevent_req *dcerpc_clusapi_ExecuteReadBatchEx_r_send(TALLOC_CTX *mem_ctx,
36448 : struct tevent_context *ev,
36449 : struct dcerpc_binding_handle *h,
36450 : struct clusapi_ExecuteReadBatchEx *r)
36451 : {
36452 : struct tevent_req *req;
36453 : struct dcerpc_clusapi_ExecuteReadBatchEx_r_state *state;
36454 : struct tevent_req *subreq;
36455 :
36456 0 : req = tevent_req_create(mem_ctx, &state,
36457 : struct dcerpc_clusapi_ExecuteReadBatchEx_r_state);
36458 0 : if (req == NULL) {
36459 0 : return NULL;
36460 : }
36461 :
36462 0 : state->out_mem_ctx = talloc_new(state);
36463 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
36464 0 : return tevent_req_post(req, ev);
36465 : }
36466 :
36467 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
36468 : NULL, &ndr_table_clusapi,
36469 0 : NDR_CLUSAPI_EXECUTEREADBATCHEX, state->out_mem_ctx, r);
36470 0 : if (tevent_req_nomem(subreq, req)) {
36471 0 : return tevent_req_post(req, ev);
36472 : }
36473 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteReadBatchEx_r_done, req);
36474 :
36475 0 : return req;
36476 : }
36477 :
36478 0 : static void dcerpc_clusapi_ExecuteReadBatchEx_r_done(struct tevent_req *subreq)
36479 : {
36480 0 : struct tevent_req *req =
36481 0 : tevent_req_callback_data(subreq,
36482 : struct tevent_req);
36483 : NTSTATUS status;
36484 :
36485 0 : status = dcerpc_binding_handle_call_recv(subreq);
36486 0 : TALLOC_FREE(subreq);
36487 0 : if (tevent_req_nterror(req, status)) {
36488 0 : return;
36489 : }
36490 :
36491 0 : tevent_req_done(req);
36492 : }
36493 :
36494 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatchEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
36495 : {
36496 0 : struct dcerpc_clusapi_ExecuteReadBatchEx_r_state *state =
36497 0 : tevent_req_data(req,
36498 : struct dcerpc_clusapi_ExecuteReadBatchEx_r_state);
36499 : NTSTATUS status;
36500 :
36501 0 : if (tevent_req_is_nterror(req, &status)) {
36502 0 : tevent_req_received(req);
36503 0 : return status;
36504 : }
36505 :
36506 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36507 :
36508 0 : tevent_req_received(req);
36509 0 : return NT_STATUS_OK;
36510 : }
36511 :
36512 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatchEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ExecuteReadBatchEx *r)
36513 : {
36514 : NTSTATUS status;
36515 :
36516 0 : status = dcerpc_binding_handle_call(h,
36517 : NULL, &ndr_table_clusapi,
36518 : NDR_CLUSAPI_EXECUTEREADBATCHEX, mem_ctx, r);
36519 :
36520 0 : return status;
36521 : }
36522 :
36523 : struct dcerpc_clusapi_ExecuteReadBatchEx_state {
36524 : struct clusapi_ExecuteReadBatchEx orig;
36525 : struct clusapi_ExecuteReadBatchEx tmp;
36526 : TALLOC_CTX *out_mem_ctx;
36527 : };
36528 :
36529 : static void dcerpc_clusapi_ExecuteReadBatchEx_done(struct tevent_req *subreq);
36530 :
36531 0 : struct tevent_req *dcerpc_clusapi_ExecuteReadBatchEx_send(TALLOC_CTX *mem_ctx,
36532 : struct tevent_context *ev,
36533 : struct dcerpc_binding_handle *h,
36534 : struct policy_handle _hKey /* [in] */,
36535 : uint32_t _cbInData /* [in] */,
36536 : uint8_t *_lpInData /* [in] [ref,size_is(cbInData)] */,
36537 : uint32_t _flags /* [in] */,
36538 : uint32_t *_cbOutData /* [out] [ref] */,
36539 : uint8_t **_lpOutData /* [out] [ref,size_is(,*cbOutData)] */,
36540 : WERROR *_rpc_status /* [out] [ref] */)
36541 : {
36542 : struct tevent_req *req;
36543 : struct dcerpc_clusapi_ExecuteReadBatchEx_state *state;
36544 : struct tevent_req *subreq;
36545 :
36546 0 : req = tevent_req_create(mem_ctx, &state,
36547 : struct dcerpc_clusapi_ExecuteReadBatchEx_state);
36548 0 : if (req == NULL) {
36549 0 : return NULL;
36550 : }
36551 0 : state->out_mem_ctx = NULL;
36552 :
36553 : /* In parameters */
36554 0 : state->orig.in.hKey = _hKey;
36555 0 : state->orig.in.cbInData = _cbInData;
36556 0 : state->orig.in.lpInData = _lpInData;
36557 0 : state->orig.in.flags = _flags;
36558 :
36559 : /* Out parameters */
36560 0 : state->orig.out.cbOutData = _cbOutData;
36561 0 : state->orig.out.lpOutData = _lpOutData;
36562 0 : state->orig.out.rpc_status = _rpc_status;
36563 :
36564 : /* Result */
36565 0 : NDR_ZERO_STRUCT(state->orig.out.result);
36566 :
36567 0 : state->out_mem_ctx = talloc_named_const(state, 0,
36568 : "dcerpc_clusapi_ExecuteReadBatchEx_out_memory");
36569 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
36570 0 : return tevent_req_post(req, ev);
36571 : }
36572 :
36573 : /* make a temporary copy, that we pass to the dispatch function */
36574 0 : state->tmp = state->orig;
36575 :
36576 0 : subreq = dcerpc_clusapi_ExecuteReadBatchEx_r_send(state, ev, h, &state->tmp);
36577 0 : if (tevent_req_nomem(subreq, req)) {
36578 0 : return tevent_req_post(req, ev);
36579 : }
36580 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ExecuteReadBatchEx_done, req);
36581 0 : return req;
36582 : }
36583 :
36584 0 : static void dcerpc_clusapi_ExecuteReadBatchEx_done(struct tevent_req *subreq)
36585 : {
36586 0 : struct tevent_req *req = tevent_req_callback_data(
36587 : subreq, struct tevent_req);
36588 0 : struct dcerpc_clusapi_ExecuteReadBatchEx_state *state = tevent_req_data(
36589 : req, struct dcerpc_clusapi_ExecuteReadBatchEx_state);
36590 : NTSTATUS status;
36591 : TALLOC_CTX *mem_ctx;
36592 :
36593 0 : if (state->out_mem_ctx) {
36594 0 : mem_ctx = state->out_mem_ctx;
36595 : } else {
36596 0 : mem_ctx = state;
36597 : }
36598 :
36599 0 : status = dcerpc_clusapi_ExecuteReadBatchEx_r_recv(subreq, mem_ctx);
36600 0 : TALLOC_FREE(subreq);
36601 0 : if (tevent_req_nterror(req, status)) {
36602 0 : return;
36603 : }
36604 :
36605 : /* Copy out parameters */
36606 0 : *state->orig.out.cbOutData = *state->tmp.out.cbOutData;
36607 0 : *state->orig.out.lpOutData = *state->tmp.out.lpOutData;
36608 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
36609 :
36610 : /* Copy result */
36611 0 : state->orig.out.result = state->tmp.out.result;
36612 :
36613 : /* Reset temporary structure */
36614 0 : NDR_ZERO_STRUCT(state->tmp);
36615 :
36616 0 : tevent_req_done(req);
36617 : }
36618 :
36619 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatchEx_recv(struct tevent_req *req,
36620 : TALLOC_CTX *mem_ctx,
36621 : WERROR *result)
36622 : {
36623 0 : struct dcerpc_clusapi_ExecuteReadBatchEx_state *state = tevent_req_data(
36624 : req, struct dcerpc_clusapi_ExecuteReadBatchEx_state);
36625 : NTSTATUS status;
36626 :
36627 0 : if (tevent_req_is_nterror(req, &status)) {
36628 0 : tevent_req_received(req);
36629 0 : return status;
36630 : }
36631 :
36632 : /* Steal possible out parameters to the callers context */
36633 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36634 :
36635 : /* Return result */
36636 0 : *result = state->orig.out.result;
36637 :
36638 0 : tevent_req_received(req);
36639 0 : return NT_STATUS_OK;
36640 : }
36641 :
36642 0 : NTSTATUS dcerpc_clusapi_ExecuteReadBatchEx(struct dcerpc_binding_handle *h,
36643 : TALLOC_CTX *mem_ctx,
36644 : struct policy_handle _hKey /* [in] */,
36645 : uint32_t _cbInData /* [in] */,
36646 : uint8_t *_lpInData /* [in] [ref,size_is(cbInData)] */,
36647 : uint32_t _flags /* [in] */,
36648 : uint32_t *_cbOutData /* [out] [ref] */,
36649 : uint8_t **_lpOutData /* [out] [ref,size_is(,*cbOutData)] */,
36650 : WERROR *_rpc_status /* [out] [ref] */,
36651 : WERROR *result)
36652 : {
36653 : struct clusapi_ExecuteReadBatchEx r;
36654 : NTSTATUS status;
36655 :
36656 : /* In parameters */
36657 0 : r.in.hKey = _hKey;
36658 0 : r.in.cbInData = _cbInData;
36659 0 : r.in.lpInData = _lpInData;
36660 0 : r.in.flags = _flags;
36661 :
36662 : /* Out parameters */
36663 0 : r.out.cbOutData = _cbOutData;
36664 0 : r.out.lpOutData = _lpOutData;
36665 0 : r.out.rpc_status = _rpc_status;
36666 :
36667 : /* Result */
36668 0 : NDR_ZERO_STRUCT(r.out.result);
36669 :
36670 0 : status = dcerpc_clusapi_ExecuteReadBatchEx_r(h, mem_ctx, &r);
36671 0 : if (!NT_STATUS_IS_OK(status)) {
36672 0 : return status;
36673 : }
36674 :
36675 : /* Return variables */
36676 0 : *_cbOutData = *r.out.cbOutData;
36677 0 : *_lpOutData = *r.out.lpOutData;
36678 0 : *_rpc_status = *r.out.rpc_status;
36679 :
36680 : /* Return result */
36681 0 : *result = r.out.result;
36682 :
36683 0 : return NT_STATUS_OK;
36684 : }
36685 :
36686 : struct dcerpc_Opnum158NotUsedOnWire_r_state {
36687 : TALLOC_CTX *out_mem_ctx;
36688 : };
36689 :
36690 : static void dcerpc_Opnum158NotUsedOnWire_r_done(struct tevent_req *subreq);
36691 :
36692 0 : struct tevent_req *dcerpc_Opnum158NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
36693 : struct tevent_context *ev,
36694 : struct dcerpc_binding_handle *h,
36695 : struct Opnum158NotUsedOnWire *r)
36696 : {
36697 : struct tevent_req *req;
36698 : struct dcerpc_Opnum158NotUsedOnWire_r_state *state;
36699 : struct tevent_req *subreq;
36700 :
36701 0 : req = tevent_req_create(mem_ctx, &state,
36702 : struct dcerpc_Opnum158NotUsedOnWire_r_state);
36703 0 : if (req == NULL) {
36704 0 : return NULL;
36705 : }
36706 :
36707 0 : state->out_mem_ctx = NULL;
36708 :
36709 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
36710 : NULL, &ndr_table_clusapi,
36711 : NDR_OPNUM158NOTUSEDONWIRE, state, r);
36712 0 : if (tevent_req_nomem(subreq, req)) {
36713 0 : return tevent_req_post(req, ev);
36714 : }
36715 0 : tevent_req_set_callback(subreq, dcerpc_Opnum158NotUsedOnWire_r_done, req);
36716 :
36717 0 : return req;
36718 : }
36719 :
36720 0 : static void dcerpc_Opnum158NotUsedOnWire_r_done(struct tevent_req *subreq)
36721 : {
36722 0 : struct tevent_req *req =
36723 0 : tevent_req_callback_data(subreq,
36724 : struct tevent_req);
36725 : NTSTATUS status;
36726 :
36727 0 : status = dcerpc_binding_handle_call_recv(subreq);
36728 0 : TALLOC_FREE(subreq);
36729 0 : if (tevent_req_nterror(req, status)) {
36730 0 : return;
36731 : }
36732 :
36733 0 : tevent_req_done(req);
36734 : }
36735 :
36736 0 : NTSTATUS dcerpc_Opnum158NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
36737 : {
36738 0 : struct dcerpc_Opnum158NotUsedOnWire_r_state *state =
36739 0 : tevent_req_data(req,
36740 : struct dcerpc_Opnum158NotUsedOnWire_r_state);
36741 : NTSTATUS status;
36742 :
36743 0 : if (tevent_req_is_nterror(req, &status)) {
36744 0 : tevent_req_received(req);
36745 0 : return status;
36746 : }
36747 :
36748 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36749 :
36750 0 : tevent_req_received(req);
36751 0 : return NT_STATUS_OK;
36752 : }
36753 :
36754 0 : NTSTATUS dcerpc_Opnum158NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum158NotUsedOnWire *r)
36755 : {
36756 : NTSTATUS status;
36757 :
36758 0 : status = dcerpc_binding_handle_call(h,
36759 : NULL, &ndr_table_clusapi,
36760 : NDR_OPNUM158NOTUSEDONWIRE, mem_ctx, r);
36761 :
36762 0 : return status;
36763 : }
36764 :
36765 : struct dcerpc_Opnum158NotUsedOnWire_state {
36766 : struct Opnum158NotUsedOnWire orig;
36767 : struct Opnum158NotUsedOnWire tmp;
36768 : TALLOC_CTX *out_mem_ctx;
36769 : };
36770 :
36771 : static void dcerpc_Opnum158NotUsedOnWire_done(struct tevent_req *subreq);
36772 :
36773 0 : struct tevent_req *dcerpc_Opnum158NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
36774 : struct tevent_context *ev,
36775 : struct dcerpc_binding_handle *h)
36776 : {
36777 : struct tevent_req *req;
36778 : struct dcerpc_Opnum158NotUsedOnWire_state *state;
36779 : struct tevent_req *subreq;
36780 :
36781 0 : req = tevent_req_create(mem_ctx, &state,
36782 : struct dcerpc_Opnum158NotUsedOnWire_state);
36783 0 : if (req == NULL) {
36784 0 : return NULL;
36785 : }
36786 0 : state->out_mem_ctx = NULL;
36787 :
36788 : /* In parameters */
36789 :
36790 : /* Out parameters */
36791 :
36792 : /* Result */
36793 0 : NDR_ZERO_STRUCT(state->orig.out.result);
36794 :
36795 : /* make a temporary copy, that we pass to the dispatch function */
36796 0 : state->tmp = state->orig;
36797 :
36798 0 : subreq = dcerpc_Opnum158NotUsedOnWire_r_send(state, ev, h, &state->tmp);
36799 0 : if (tevent_req_nomem(subreq, req)) {
36800 0 : return tevent_req_post(req, ev);
36801 : }
36802 0 : tevent_req_set_callback(subreq, dcerpc_Opnum158NotUsedOnWire_done, req);
36803 0 : return req;
36804 : }
36805 :
36806 0 : static void dcerpc_Opnum158NotUsedOnWire_done(struct tevent_req *subreq)
36807 : {
36808 0 : struct tevent_req *req = tevent_req_callback_data(
36809 : subreq, struct tevent_req);
36810 0 : struct dcerpc_Opnum158NotUsedOnWire_state *state = tevent_req_data(
36811 : req, struct dcerpc_Opnum158NotUsedOnWire_state);
36812 : NTSTATUS status;
36813 : TALLOC_CTX *mem_ctx;
36814 :
36815 0 : if (state->out_mem_ctx) {
36816 0 : mem_ctx = state->out_mem_ctx;
36817 : } else {
36818 0 : mem_ctx = state;
36819 : }
36820 :
36821 0 : status = dcerpc_Opnum158NotUsedOnWire_r_recv(subreq, mem_ctx);
36822 0 : TALLOC_FREE(subreq);
36823 0 : if (tevent_req_nterror(req, status)) {
36824 0 : return;
36825 : }
36826 :
36827 : /* Copy out parameters */
36828 :
36829 : /* Copy result */
36830 0 : state->orig.out.result = state->tmp.out.result;
36831 :
36832 : /* Reset temporary structure */
36833 0 : NDR_ZERO_STRUCT(state->tmp);
36834 :
36835 0 : tevent_req_done(req);
36836 : }
36837 :
36838 0 : NTSTATUS dcerpc_Opnum158NotUsedOnWire_recv(struct tevent_req *req,
36839 : TALLOC_CTX *mem_ctx,
36840 : WERROR *result)
36841 : {
36842 0 : struct dcerpc_Opnum158NotUsedOnWire_state *state = tevent_req_data(
36843 : req, struct dcerpc_Opnum158NotUsedOnWire_state);
36844 : NTSTATUS status;
36845 :
36846 0 : if (tevent_req_is_nterror(req, &status)) {
36847 0 : tevent_req_received(req);
36848 0 : return status;
36849 : }
36850 :
36851 : /* Steal possible out parameters to the callers context */
36852 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36853 :
36854 : /* Return result */
36855 0 : *result = state->orig.out.result;
36856 :
36857 0 : tevent_req_received(req);
36858 0 : return NT_STATUS_OK;
36859 : }
36860 :
36861 0 : NTSTATUS dcerpc_Opnum158NotUsedOnWire(struct dcerpc_binding_handle *h,
36862 : TALLOC_CTX *mem_ctx,
36863 : WERROR *result)
36864 : {
36865 : struct Opnum158NotUsedOnWire r;
36866 : NTSTATUS status;
36867 :
36868 : /* In parameters */
36869 :
36870 : /* Out parameters */
36871 :
36872 : /* Result */
36873 0 : NDR_ZERO_STRUCT(r.out.result);
36874 :
36875 0 : status = dcerpc_Opnum158NotUsedOnWire_r(h, mem_ctx, &r);
36876 0 : if (!NT_STATUS_IS_OK(status)) {
36877 0 : return status;
36878 : }
36879 :
36880 : /* Return variables */
36881 :
36882 : /* Return result */
36883 0 : *result = r.out.result;
36884 :
36885 0 : return NT_STATUS_OK;
36886 : }
36887 :
36888 : struct dcerpc_Opnum159NotUsedOnWire_r_state {
36889 : TALLOC_CTX *out_mem_ctx;
36890 : };
36891 :
36892 : static void dcerpc_Opnum159NotUsedOnWire_r_done(struct tevent_req *subreq);
36893 :
36894 0 : struct tevent_req *dcerpc_Opnum159NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
36895 : struct tevent_context *ev,
36896 : struct dcerpc_binding_handle *h,
36897 : struct Opnum159NotUsedOnWire *r)
36898 : {
36899 : struct tevent_req *req;
36900 : struct dcerpc_Opnum159NotUsedOnWire_r_state *state;
36901 : struct tevent_req *subreq;
36902 :
36903 0 : req = tevent_req_create(mem_ctx, &state,
36904 : struct dcerpc_Opnum159NotUsedOnWire_r_state);
36905 0 : if (req == NULL) {
36906 0 : return NULL;
36907 : }
36908 :
36909 0 : state->out_mem_ctx = NULL;
36910 :
36911 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
36912 : NULL, &ndr_table_clusapi,
36913 : NDR_OPNUM159NOTUSEDONWIRE, state, r);
36914 0 : if (tevent_req_nomem(subreq, req)) {
36915 0 : return tevent_req_post(req, ev);
36916 : }
36917 0 : tevent_req_set_callback(subreq, dcerpc_Opnum159NotUsedOnWire_r_done, req);
36918 :
36919 0 : return req;
36920 : }
36921 :
36922 0 : static void dcerpc_Opnum159NotUsedOnWire_r_done(struct tevent_req *subreq)
36923 : {
36924 0 : struct tevent_req *req =
36925 0 : tevent_req_callback_data(subreq,
36926 : struct tevent_req);
36927 : NTSTATUS status;
36928 :
36929 0 : status = dcerpc_binding_handle_call_recv(subreq);
36930 0 : TALLOC_FREE(subreq);
36931 0 : if (tevent_req_nterror(req, status)) {
36932 0 : return;
36933 : }
36934 :
36935 0 : tevent_req_done(req);
36936 : }
36937 :
36938 0 : NTSTATUS dcerpc_Opnum159NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
36939 : {
36940 0 : struct dcerpc_Opnum159NotUsedOnWire_r_state *state =
36941 0 : tevent_req_data(req,
36942 : struct dcerpc_Opnum159NotUsedOnWire_r_state);
36943 : NTSTATUS status;
36944 :
36945 0 : if (tevent_req_is_nterror(req, &status)) {
36946 0 : tevent_req_received(req);
36947 0 : return status;
36948 : }
36949 :
36950 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
36951 :
36952 0 : tevent_req_received(req);
36953 0 : return NT_STATUS_OK;
36954 : }
36955 :
36956 0 : NTSTATUS dcerpc_Opnum159NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum159NotUsedOnWire *r)
36957 : {
36958 : NTSTATUS status;
36959 :
36960 0 : status = dcerpc_binding_handle_call(h,
36961 : NULL, &ndr_table_clusapi,
36962 : NDR_OPNUM159NOTUSEDONWIRE, mem_ctx, r);
36963 :
36964 0 : return status;
36965 : }
36966 :
36967 : struct dcerpc_Opnum159NotUsedOnWire_state {
36968 : struct Opnum159NotUsedOnWire orig;
36969 : struct Opnum159NotUsedOnWire tmp;
36970 : TALLOC_CTX *out_mem_ctx;
36971 : };
36972 :
36973 : static void dcerpc_Opnum159NotUsedOnWire_done(struct tevent_req *subreq);
36974 :
36975 0 : struct tevent_req *dcerpc_Opnum159NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
36976 : struct tevent_context *ev,
36977 : struct dcerpc_binding_handle *h)
36978 : {
36979 : struct tevent_req *req;
36980 : struct dcerpc_Opnum159NotUsedOnWire_state *state;
36981 : struct tevent_req *subreq;
36982 :
36983 0 : req = tevent_req_create(mem_ctx, &state,
36984 : struct dcerpc_Opnum159NotUsedOnWire_state);
36985 0 : if (req == NULL) {
36986 0 : return NULL;
36987 : }
36988 0 : state->out_mem_ctx = NULL;
36989 :
36990 : /* In parameters */
36991 :
36992 : /* Out parameters */
36993 :
36994 : /* Result */
36995 0 : NDR_ZERO_STRUCT(state->orig.out.result);
36996 :
36997 : /* make a temporary copy, that we pass to the dispatch function */
36998 0 : state->tmp = state->orig;
36999 :
37000 0 : subreq = dcerpc_Opnum159NotUsedOnWire_r_send(state, ev, h, &state->tmp);
37001 0 : if (tevent_req_nomem(subreq, req)) {
37002 0 : return tevent_req_post(req, ev);
37003 : }
37004 0 : tevent_req_set_callback(subreq, dcerpc_Opnum159NotUsedOnWire_done, req);
37005 0 : return req;
37006 : }
37007 :
37008 0 : static void dcerpc_Opnum159NotUsedOnWire_done(struct tevent_req *subreq)
37009 : {
37010 0 : struct tevent_req *req = tevent_req_callback_data(
37011 : subreq, struct tevent_req);
37012 0 : struct dcerpc_Opnum159NotUsedOnWire_state *state = tevent_req_data(
37013 : req, struct dcerpc_Opnum159NotUsedOnWire_state);
37014 : NTSTATUS status;
37015 : TALLOC_CTX *mem_ctx;
37016 :
37017 0 : if (state->out_mem_ctx) {
37018 0 : mem_ctx = state->out_mem_ctx;
37019 : } else {
37020 0 : mem_ctx = state;
37021 : }
37022 :
37023 0 : status = dcerpc_Opnum159NotUsedOnWire_r_recv(subreq, mem_ctx);
37024 0 : TALLOC_FREE(subreq);
37025 0 : if (tevent_req_nterror(req, status)) {
37026 0 : return;
37027 : }
37028 :
37029 : /* Copy out parameters */
37030 :
37031 : /* Copy result */
37032 0 : state->orig.out.result = state->tmp.out.result;
37033 :
37034 : /* Reset temporary structure */
37035 0 : NDR_ZERO_STRUCT(state->tmp);
37036 :
37037 0 : tevent_req_done(req);
37038 : }
37039 :
37040 0 : NTSTATUS dcerpc_Opnum159NotUsedOnWire_recv(struct tevent_req *req,
37041 : TALLOC_CTX *mem_ctx,
37042 : WERROR *result)
37043 : {
37044 0 : struct dcerpc_Opnum159NotUsedOnWire_state *state = tevent_req_data(
37045 : req, struct dcerpc_Opnum159NotUsedOnWire_state);
37046 : NTSTATUS status;
37047 :
37048 0 : if (tevent_req_is_nterror(req, &status)) {
37049 0 : tevent_req_received(req);
37050 0 : return status;
37051 : }
37052 :
37053 : /* Steal possible out parameters to the callers context */
37054 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37055 :
37056 : /* Return result */
37057 0 : *result = state->orig.out.result;
37058 :
37059 0 : tevent_req_received(req);
37060 0 : return NT_STATUS_OK;
37061 : }
37062 :
37063 0 : NTSTATUS dcerpc_Opnum159NotUsedOnWire(struct dcerpc_binding_handle *h,
37064 : TALLOC_CTX *mem_ctx,
37065 : WERROR *result)
37066 : {
37067 : struct Opnum159NotUsedOnWire r;
37068 : NTSTATUS status;
37069 :
37070 : /* In parameters */
37071 :
37072 : /* Out parameters */
37073 :
37074 : /* Result */
37075 0 : NDR_ZERO_STRUCT(r.out.result);
37076 :
37077 0 : status = dcerpc_Opnum159NotUsedOnWire_r(h, mem_ctx, &r);
37078 0 : if (!NT_STATUS_IS_OK(status)) {
37079 0 : return status;
37080 : }
37081 :
37082 : /* Return variables */
37083 :
37084 : /* Return result */
37085 0 : *result = r.out.result;
37086 :
37087 0 : return NT_STATUS_OK;
37088 : }
37089 :
37090 : struct dcerpc_Opnum160NotUsedOnWire_r_state {
37091 : TALLOC_CTX *out_mem_ctx;
37092 : };
37093 :
37094 : static void dcerpc_Opnum160NotUsedOnWire_r_done(struct tevent_req *subreq);
37095 :
37096 0 : struct tevent_req *dcerpc_Opnum160NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
37097 : struct tevent_context *ev,
37098 : struct dcerpc_binding_handle *h,
37099 : struct Opnum160NotUsedOnWire *r)
37100 : {
37101 : struct tevent_req *req;
37102 : struct dcerpc_Opnum160NotUsedOnWire_r_state *state;
37103 : struct tevent_req *subreq;
37104 :
37105 0 : req = tevent_req_create(mem_ctx, &state,
37106 : struct dcerpc_Opnum160NotUsedOnWire_r_state);
37107 0 : if (req == NULL) {
37108 0 : return NULL;
37109 : }
37110 :
37111 0 : state->out_mem_ctx = NULL;
37112 :
37113 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
37114 : NULL, &ndr_table_clusapi,
37115 : NDR_OPNUM160NOTUSEDONWIRE, state, r);
37116 0 : if (tevent_req_nomem(subreq, req)) {
37117 0 : return tevent_req_post(req, ev);
37118 : }
37119 0 : tevent_req_set_callback(subreq, dcerpc_Opnum160NotUsedOnWire_r_done, req);
37120 :
37121 0 : return req;
37122 : }
37123 :
37124 0 : static void dcerpc_Opnum160NotUsedOnWire_r_done(struct tevent_req *subreq)
37125 : {
37126 0 : struct tevent_req *req =
37127 0 : tevent_req_callback_data(subreq,
37128 : struct tevent_req);
37129 : NTSTATUS status;
37130 :
37131 0 : status = dcerpc_binding_handle_call_recv(subreq);
37132 0 : TALLOC_FREE(subreq);
37133 0 : if (tevent_req_nterror(req, status)) {
37134 0 : return;
37135 : }
37136 :
37137 0 : tevent_req_done(req);
37138 : }
37139 :
37140 0 : NTSTATUS dcerpc_Opnum160NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
37141 : {
37142 0 : struct dcerpc_Opnum160NotUsedOnWire_r_state *state =
37143 0 : tevent_req_data(req,
37144 : struct dcerpc_Opnum160NotUsedOnWire_r_state);
37145 : NTSTATUS status;
37146 :
37147 0 : if (tevent_req_is_nterror(req, &status)) {
37148 0 : tevent_req_received(req);
37149 0 : return status;
37150 : }
37151 :
37152 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37153 :
37154 0 : tevent_req_received(req);
37155 0 : return NT_STATUS_OK;
37156 : }
37157 :
37158 0 : NTSTATUS dcerpc_Opnum160NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum160NotUsedOnWire *r)
37159 : {
37160 : NTSTATUS status;
37161 :
37162 0 : status = dcerpc_binding_handle_call(h,
37163 : NULL, &ndr_table_clusapi,
37164 : NDR_OPNUM160NOTUSEDONWIRE, mem_ctx, r);
37165 :
37166 0 : return status;
37167 : }
37168 :
37169 : struct dcerpc_Opnum160NotUsedOnWire_state {
37170 : struct Opnum160NotUsedOnWire orig;
37171 : struct Opnum160NotUsedOnWire tmp;
37172 : TALLOC_CTX *out_mem_ctx;
37173 : };
37174 :
37175 : static void dcerpc_Opnum160NotUsedOnWire_done(struct tevent_req *subreq);
37176 :
37177 0 : struct tevent_req *dcerpc_Opnum160NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
37178 : struct tevent_context *ev,
37179 : struct dcerpc_binding_handle *h)
37180 : {
37181 : struct tevent_req *req;
37182 : struct dcerpc_Opnum160NotUsedOnWire_state *state;
37183 : struct tevent_req *subreq;
37184 :
37185 0 : req = tevent_req_create(mem_ctx, &state,
37186 : struct dcerpc_Opnum160NotUsedOnWire_state);
37187 0 : if (req == NULL) {
37188 0 : return NULL;
37189 : }
37190 0 : state->out_mem_ctx = NULL;
37191 :
37192 : /* In parameters */
37193 :
37194 : /* Out parameters */
37195 :
37196 : /* Result */
37197 0 : NDR_ZERO_STRUCT(state->orig.out.result);
37198 :
37199 : /* make a temporary copy, that we pass to the dispatch function */
37200 0 : state->tmp = state->orig;
37201 :
37202 0 : subreq = dcerpc_Opnum160NotUsedOnWire_r_send(state, ev, h, &state->tmp);
37203 0 : if (tevent_req_nomem(subreq, req)) {
37204 0 : return tevent_req_post(req, ev);
37205 : }
37206 0 : tevent_req_set_callback(subreq, dcerpc_Opnum160NotUsedOnWire_done, req);
37207 0 : return req;
37208 : }
37209 :
37210 0 : static void dcerpc_Opnum160NotUsedOnWire_done(struct tevent_req *subreq)
37211 : {
37212 0 : struct tevent_req *req = tevent_req_callback_data(
37213 : subreq, struct tevent_req);
37214 0 : struct dcerpc_Opnum160NotUsedOnWire_state *state = tevent_req_data(
37215 : req, struct dcerpc_Opnum160NotUsedOnWire_state);
37216 : NTSTATUS status;
37217 : TALLOC_CTX *mem_ctx;
37218 :
37219 0 : if (state->out_mem_ctx) {
37220 0 : mem_ctx = state->out_mem_ctx;
37221 : } else {
37222 0 : mem_ctx = state;
37223 : }
37224 :
37225 0 : status = dcerpc_Opnum160NotUsedOnWire_r_recv(subreq, mem_ctx);
37226 0 : TALLOC_FREE(subreq);
37227 0 : if (tevent_req_nterror(req, status)) {
37228 0 : return;
37229 : }
37230 :
37231 : /* Copy out parameters */
37232 :
37233 : /* Copy result */
37234 0 : state->orig.out.result = state->tmp.out.result;
37235 :
37236 : /* Reset temporary structure */
37237 0 : NDR_ZERO_STRUCT(state->tmp);
37238 :
37239 0 : tevent_req_done(req);
37240 : }
37241 :
37242 0 : NTSTATUS dcerpc_Opnum160NotUsedOnWire_recv(struct tevent_req *req,
37243 : TALLOC_CTX *mem_ctx,
37244 : WERROR *result)
37245 : {
37246 0 : struct dcerpc_Opnum160NotUsedOnWire_state *state = tevent_req_data(
37247 : req, struct dcerpc_Opnum160NotUsedOnWire_state);
37248 : NTSTATUS status;
37249 :
37250 0 : if (tevent_req_is_nterror(req, &status)) {
37251 0 : tevent_req_received(req);
37252 0 : return status;
37253 : }
37254 :
37255 : /* Steal possible out parameters to the callers context */
37256 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37257 :
37258 : /* Return result */
37259 0 : *result = state->orig.out.result;
37260 :
37261 0 : tevent_req_received(req);
37262 0 : return NT_STATUS_OK;
37263 : }
37264 :
37265 0 : NTSTATUS dcerpc_Opnum160NotUsedOnWire(struct dcerpc_binding_handle *h,
37266 : TALLOC_CTX *mem_ctx,
37267 : WERROR *result)
37268 : {
37269 : struct Opnum160NotUsedOnWire r;
37270 : NTSTATUS status;
37271 :
37272 : /* In parameters */
37273 :
37274 : /* Out parameters */
37275 :
37276 : /* Result */
37277 0 : NDR_ZERO_STRUCT(r.out.result);
37278 :
37279 0 : status = dcerpc_Opnum160NotUsedOnWire_r(h, mem_ctx, &r);
37280 0 : if (!NT_STATUS_IS_OK(status)) {
37281 0 : return status;
37282 : }
37283 :
37284 : /* Return variables */
37285 :
37286 : /* Return result */
37287 0 : *result = r.out.result;
37288 :
37289 0 : return NT_STATUS_OK;
37290 : }
37291 :
37292 : struct dcerpc_Opnum161NotUsedOnWire_r_state {
37293 : TALLOC_CTX *out_mem_ctx;
37294 : };
37295 :
37296 : static void dcerpc_Opnum161NotUsedOnWire_r_done(struct tevent_req *subreq);
37297 :
37298 0 : struct tevent_req *dcerpc_Opnum161NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
37299 : struct tevent_context *ev,
37300 : struct dcerpc_binding_handle *h,
37301 : struct Opnum161NotUsedOnWire *r)
37302 : {
37303 : struct tevent_req *req;
37304 : struct dcerpc_Opnum161NotUsedOnWire_r_state *state;
37305 : struct tevent_req *subreq;
37306 :
37307 0 : req = tevent_req_create(mem_ctx, &state,
37308 : struct dcerpc_Opnum161NotUsedOnWire_r_state);
37309 0 : if (req == NULL) {
37310 0 : return NULL;
37311 : }
37312 :
37313 0 : state->out_mem_ctx = NULL;
37314 :
37315 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
37316 : NULL, &ndr_table_clusapi,
37317 : NDR_OPNUM161NOTUSEDONWIRE, state, r);
37318 0 : if (tevent_req_nomem(subreq, req)) {
37319 0 : return tevent_req_post(req, ev);
37320 : }
37321 0 : tevent_req_set_callback(subreq, dcerpc_Opnum161NotUsedOnWire_r_done, req);
37322 :
37323 0 : return req;
37324 : }
37325 :
37326 0 : static void dcerpc_Opnum161NotUsedOnWire_r_done(struct tevent_req *subreq)
37327 : {
37328 0 : struct tevent_req *req =
37329 0 : tevent_req_callback_data(subreq,
37330 : struct tevent_req);
37331 : NTSTATUS status;
37332 :
37333 0 : status = dcerpc_binding_handle_call_recv(subreq);
37334 0 : TALLOC_FREE(subreq);
37335 0 : if (tevent_req_nterror(req, status)) {
37336 0 : return;
37337 : }
37338 :
37339 0 : tevent_req_done(req);
37340 : }
37341 :
37342 0 : NTSTATUS dcerpc_Opnum161NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
37343 : {
37344 0 : struct dcerpc_Opnum161NotUsedOnWire_r_state *state =
37345 0 : tevent_req_data(req,
37346 : struct dcerpc_Opnum161NotUsedOnWire_r_state);
37347 : NTSTATUS status;
37348 :
37349 0 : if (tevent_req_is_nterror(req, &status)) {
37350 0 : tevent_req_received(req);
37351 0 : return status;
37352 : }
37353 :
37354 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37355 :
37356 0 : tevent_req_received(req);
37357 0 : return NT_STATUS_OK;
37358 : }
37359 :
37360 0 : NTSTATUS dcerpc_Opnum161NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum161NotUsedOnWire *r)
37361 : {
37362 : NTSTATUS status;
37363 :
37364 0 : status = dcerpc_binding_handle_call(h,
37365 : NULL, &ndr_table_clusapi,
37366 : NDR_OPNUM161NOTUSEDONWIRE, mem_ctx, r);
37367 :
37368 0 : return status;
37369 : }
37370 :
37371 : struct dcerpc_Opnum161NotUsedOnWire_state {
37372 : struct Opnum161NotUsedOnWire orig;
37373 : struct Opnum161NotUsedOnWire tmp;
37374 : TALLOC_CTX *out_mem_ctx;
37375 : };
37376 :
37377 : static void dcerpc_Opnum161NotUsedOnWire_done(struct tevent_req *subreq);
37378 :
37379 0 : struct tevent_req *dcerpc_Opnum161NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
37380 : struct tevent_context *ev,
37381 : struct dcerpc_binding_handle *h)
37382 : {
37383 : struct tevent_req *req;
37384 : struct dcerpc_Opnum161NotUsedOnWire_state *state;
37385 : struct tevent_req *subreq;
37386 :
37387 0 : req = tevent_req_create(mem_ctx, &state,
37388 : struct dcerpc_Opnum161NotUsedOnWire_state);
37389 0 : if (req == NULL) {
37390 0 : return NULL;
37391 : }
37392 0 : state->out_mem_ctx = NULL;
37393 :
37394 : /* In parameters */
37395 :
37396 : /* Out parameters */
37397 :
37398 : /* Result */
37399 0 : NDR_ZERO_STRUCT(state->orig.out.result);
37400 :
37401 : /* make a temporary copy, that we pass to the dispatch function */
37402 0 : state->tmp = state->orig;
37403 :
37404 0 : subreq = dcerpc_Opnum161NotUsedOnWire_r_send(state, ev, h, &state->tmp);
37405 0 : if (tevent_req_nomem(subreq, req)) {
37406 0 : return tevent_req_post(req, ev);
37407 : }
37408 0 : tevent_req_set_callback(subreq, dcerpc_Opnum161NotUsedOnWire_done, req);
37409 0 : return req;
37410 : }
37411 :
37412 0 : static void dcerpc_Opnum161NotUsedOnWire_done(struct tevent_req *subreq)
37413 : {
37414 0 : struct tevent_req *req = tevent_req_callback_data(
37415 : subreq, struct tevent_req);
37416 0 : struct dcerpc_Opnum161NotUsedOnWire_state *state = tevent_req_data(
37417 : req, struct dcerpc_Opnum161NotUsedOnWire_state);
37418 : NTSTATUS status;
37419 : TALLOC_CTX *mem_ctx;
37420 :
37421 0 : if (state->out_mem_ctx) {
37422 0 : mem_ctx = state->out_mem_ctx;
37423 : } else {
37424 0 : mem_ctx = state;
37425 : }
37426 :
37427 0 : status = dcerpc_Opnum161NotUsedOnWire_r_recv(subreq, mem_ctx);
37428 0 : TALLOC_FREE(subreq);
37429 0 : if (tevent_req_nterror(req, status)) {
37430 0 : return;
37431 : }
37432 :
37433 : /* Copy out parameters */
37434 :
37435 : /* Copy result */
37436 0 : state->orig.out.result = state->tmp.out.result;
37437 :
37438 : /* Reset temporary structure */
37439 0 : NDR_ZERO_STRUCT(state->tmp);
37440 :
37441 0 : tevent_req_done(req);
37442 : }
37443 :
37444 0 : NTSTATUS dcerpc_Opnum161NotUsedOnWire_recv(struct tevent_req *req,
37445 : TALLOC_CTX *mem_ctx,
37446 : WERROR *result)
37447 : {
37448 0 : struct dcerpc_Opnum161NotUsedOnWire_state *state = tevent_req_data(
37449 : req, struct dcerpc_Opnum161NotUsedOnWire_state);
37450 : NTSTATUS status;
37451 :
37452 0 : if (tevent_req_is_nterror(req, &status)) {
37453 0 : tevent_req_received(req);
37454 0 : return status;
37455 : }
37456 :
37457 : /* Steal possible out parameters to the callers context */
37458 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37459 :
37460 : /* Return result */
37461 0 : *result = state->orig.out.result;
37462 :
37463 0 : tevent_req_received(req);
37464 0 : return NT_STATUS_OK;
37465 : }
37466 :
37467 0 : NTSTATUS dcerpc_Opnum161NotUsedOnWire(struct dcerpc_binding_handle *h,
37468 : TALLOC_CTX *mem_ctx,
37469 : WERROR *result)
37470 : {
37471 : struct Opnum161NotUsedOnWire r;
37472 : NTSTATUS status;
37473 :
37474 : /* In parameters */
37475 :
37476 : /* Out parameters */
37477 :
37478 : /* Result */
37479 0 : NDR_ZERO_STRUCT(r.out.result);
37480 :
37481 0 : status = dcerpc_Opnum161NotUsedOnWire_r(h, mem_ctx, &r);
37482 0 : if (!NT_STATUS_IS_OK(status)) {
37483 0 : return status;
37484 : }
37485 :
37486 : /* Return variables */
37487 :
37488 : /* Return result */
37489 0 : *result = r.out.result;
37490 :
37491 0 : return NT_STATUS_OK;
37492 : }
37493 :
37494 : struct dcerpc_Opnum162NotUsedOnWire_r_state {
37495 : TALLOC_CTX *out_mem_ctx;
37496 : };
37497 :
37498 : static void dcerpc_Opnum162NotUsedOnWire_r_done(struct tevent_req *subreq);
37499 :
37500 0 : struct tevent_req *dcerpc_Opnum162NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
37501 : struct tevent_context *ev,
37502 : struct dcerpc_binding_handle *h,
37503 : struct Opnum162NotUsedOnWire *r)
37504 : {
37505 : struct tevent_req *req;
37506 : struct dcerpc_Opnum162NotUsedOnWire_r_state *state;
37507 : struct tevent_req *subreq;
37508 :
37509 0 : req = tevent_req_create(mem_ctx, &state,
37510 : struct dcerpc_Opnum162NotUsedOnWire_r_state);
37511 0 : if (req == NULL) {
37512 0 : return NULL;
37513 : }
37514 :
37515 0 : state->out_mem_ctx = NULL;
37516 :
37517 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
37518 : NULL, &ndr_table_clusapi,
37519 : NDR_OPNUM162NOTUSEDONWIRE, state, r);
37520 0 : if (tevent_req_nomem(subreq, req)) {
37521 0 : return tevent_req_post(req, ev);
37522 : }
37523 0 : tevent_req_set_callback(subreq, dcerpc_Opnum162NotUsedOnWire_r_done, req);
37524 :
37525 0 : return req;
37526 : }
37527 :
37528 0 : static void dcerpc_Opnum162NotUsedOnWire_r_done(struct tevent_req *subreq)
37529 : {
37530 0 : struct tevent_req *req =
37531 0 : tevent_req_callback_data(subreq,
37532 : struct tevent_req);
37533 : NTSTATUS status;
37534 :
37535 0 : status = dcerpc_binding_handle_call_recv(subreq);
37536 0 : TALLOC_FREE(subreq);
37537 0 : if (tevent_req_nterror(req, status)) {
37538 0 : return;
37539 : }
37540 :
37541 0 : tevent_req_done(req);
37542 : }
37543 :
37544 0 : NTSTATUS dcerpc_Opnum162NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
37545 : {
37546 0 : struct dcerpc_Opnum162NotUsedOnWire_r_state *state =
37547 0 : tevent_req_data(req,
37548 : struct dcerpc_Opnum162NotUsedOnWire_r_state);
37549 : NTSTATUS status;
37550 :
37551 0 : if (tevent_req_is_nterror(req, &status)) {
37552 0 : tevent_req_received(req);
37553 0 : return status;
37554 : }
37555 :
37556 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37557 :
37558 0 : tevent_req_received(req);
37559 0 : return NT_STATUS_OK;
37560 : }
37561 :
37562 0 : NTSTATUS dcerpc_Opnum162NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum162NotUsedOnWire *r)
37563 : {
37564 : NTSTATUS status;
37565 :
37566 0 : status = dcerpc_binding_handle_call(h,
37567 : NULL, &ndr_table_clusapi,
37568 : NDR_OPNUM162NOTUSEDONWIRE, mem_ctx, r);
37569 :
37570 0 : return status;
37571 : }
37572 :
37573 : struct dcerpc_Opnum162NotUsedOnWire_state {
37574 : struct Opnum162NotUsedOnWire orig;
37575 : struct Opnum162NotUsedOnWire tmp;
37576 : TALLOC_CTX *out_mem_ctx;
37577 : };
37578 :
37579 : static void dcerpc_Opnum162NotUsedOnWire_done(struct tevent_req *subreq);
37580 :
37581 0 : struct tevent_req *dcerpc_Opnum162NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
37582 : struct tevent_context *ev,
37583 : struct dcerpc_binding_handle *h)
37584 : {
37585 : struct tevent_req *req;
37586 : struct dcerpc_Opnum162NotUsedOnWire_state *state;
37587 : struct tevent_req *subreq;
37588 :
37589 0 : req = tevent_req_create(mem_ctx, &state,
37590 : struct dcerpc_Opnum162NotUsedOnWire_state);
37591 0 : if (req == NULL) {
37592 0 : return NULL;
37593 : }
37594 0 : state->out_mem_ctx = NULL;
37595 :
37596 : /* In parameters */
37597 :
37598 : /* Out parameters */
37599 :
37600 : /* Result */
37601 0 : NDR_ZERO_STRUCT(state->orig.out.result);
37602 :
37603 : /* make a temporary copy, that we pass to the dispatch function */
37604 0 : state->tmp = state->orig;
37605 :
37606 0 : subreq = dcerpc_Opnum162NotUsedOnWire_r_send(state, ev, h, &state->tmp);
37607 0 : if (tevent_req_nomem(subreq, req)) {
37608 0 : return tevent_req_post(req, ev);
37609 : }
37610 0 : tevent_req_set_callback(subreq, dcerpc_Opnum162NotUsedOnWire_done, req);
37611 0 : return req;
37612 : }
37613 :
37614 0 : static void dcerpc_Opnum162NotUsedOnWire_done(struct tevent_req *subreq)
37615 : {
37616 0 : struct tevent_req *req = tevent_req_callback_data(
37617 : subreq, struct tevent_req);
37618 0 : struct dcerpc_Opnum162NotUsedOnWire_state *state = tevent_req_data(
37619 : req, struct dcerpc_Opnum162NotUsedOnWire_state);
37620 : NTSTATUS status;
37621 : TALLOC_CTX *mem_ctx;
37622 :
37623 0 : if (state->out_mem_ctx) {
37624 0 : mem_ctx = state->out_mem_ctx;
37625 : } else {
37626 0 : mem_ctx = state;
37627 : }
37628 :
37629 0 : status = dcerpc_Opnum162NotUsedOnWire_r_recv(subreq, mem_ctx);
37630 0 : TALLOC_FREE(subreq);
37631 0 : if (tevent_req_nterror(req, status)) {
37632 0 : return;
37633 : }
37634 :
37635 : /* Copy out parameters */
37636 :
37637 : /* Copy result */
37638 0 : state->orig.out.result = state->tmp.out.result;
37639 :
37640 : /* Reset temporary structure */
37641 0 : NDR_ZERO_STRUCT(state->tmp);
37642 :
37643 0 : tevent_req_done(req);
37644 : }
37645 :
37646 0 : NTSTATUS dcerpc_Opnum162NotUsedOnWire_recv(struct tevent_req *req,
37647 : TALLOC_CTX *mem_ctx,
37648 : WERROR *result)
37649 : {
37650 0 : struct dcerpc_Opnum162NotUsedOnWire_state *state = tevent_req_data(
37651 : req, struct dcerpc_Opnum162NotUsedOnWire_state);
37652 : NTSTATUS status;
37653 :
37654 0 : if (tevent_req_is_nterror(req, &status)) {
37655 0 : tevent_req_received(req);
37656 0 : return status;
37657 : }
37658 :
37659 : /* Steal possible out parameters to the callers context */
37660 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37661 :
37662 : /* Return result */
37663 0 : *result = state->orig.out.result;
37664 :
37665 0 : tevent_req_received(req);
37666 0 : return NT_STATUS_OK;
37667 : }
37668 :
37669 0 : NTSTATUS dcerpc_Opnum162NotUsedOnWire(struct dcerpc_binding_handle *h,
37670 : TALLOC_CTX *mem_ctx,
37671 : WERROR *result)
37672 : {
37673 : struct Opnum162NotUsedOnWire r;
37674 : NTSTATUS status;
37675 :
37676 : /* In parameters */
37677 :
37678 : /* Out parameters */
37679 :
37680 : /* Result */
37681 0 : NDR_ZERO_STRUCT(r.out.result);
37682 :
37683 0 : status = dcerpc_Opnum162NotUsedOnWire_r(h, mem_ctx, &r);
37684 0 : if (!NT_STATUS_IS_OK(status)) {
37685 0 : return status;
37686 : }
37687 :
37688 : /* Return variables */
37689 :
37690 : /* Return result */
37691 0 : *result = r.out.result;
37692 :
37693 0 : return NT_STATUS_OK;
37694 : }
37695 :
37696 : struct dcerpc_clusapi_CreateGroupSet_r_state {
37697 : TALLOC_CTX *out_mem_ctx;
37698 : };
37699 :
37700 : static void dcerpc_clusapi_CreateGroupSet_r_done(struct tevent_req *subreq);
37701 :
37702 0 : struct tevent_req *dcerpc_clusapi_CreateGroupSet_r_send(TALLOC_CTX *mem_ctx,
37703 : struct tevent_context *ev,
37704 : struct dcerpc_binding_handle *h,
37705 : struct clusapi_CreateGroupSet *r)
37706 : {
37707 : struct tevent_req *req;
37708 : struct dcerpc_clusapi_CreateGroupSet_r_state *state;
37709 : struct tevent_req *subreq;
37710 :
37711 0 : req = tevent_req_create(mem_ctx, &state,
37712 : struct dcerpc_clusapi_CreateGroupSet_r_state);
37713 0 : if (req == NULL) {
37714 0 : return NULL;
37715 : }
37716 :
37717 0 : state->out_mem_ctx = talloc_new(state);
37718 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
37719 0 : return tevent_req_post(req, ev);
37720 : }
37721 :
37722 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
37723 : NULL, &ndr_table_clusapi,
37724 0 : NDR_CLUSAPI_CREATEGROUPSET, state->out_mem_ctx, r);
37725 0 : if (tevent_req_nomem(subreq, req)) {
37726 0 : return tevent_req_post(req, ev);
37727 : }
37728 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupSet_r_done, req);
37729 :
37730 0 : return req;
37731 : }
37732 :
37733 0 : static void dcerpc_clusapi_CreateGroupSet_r_done(struct tevent_req *subreq)
37734 : {
37735 0 : struct tevent_req *req =
37736 0 : tevent_req_callback_data(subreq,
37737 : struct tevent_req);
37738 : NTSTATUS status;
37739 :
37740 0 : status = dcerpc_binding_handle_call_recv(subreq);
37741 0 : TALLOC_FREE(subreq);
37742 0 : if (tevent_req_nterror(req, status)) {
37743 0 : return;
37744 : }
37745 :
37746 0 : tevent_req_done(req);
37747 : }
37748 :
37749 0 : NTSTATUS dcerpc_clusapi_CreateGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
37750 : {
37751 0 : struct dcerpc_clusapi_CreateGroupSet_r_state *state =
37752 0 : tevent_req_data(req,
37753 : struct dcerpc_clusapi_CreateGroupSet_r_state);
37754 : NTSTATUS status;
37755 :
37756 0 : if (tevent_req_is_nterror(req, &status)) {
37757 0 : tevent_req_received(req);
37758 0 : return status;
37759 : }
37760 :
37761 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37762 :
37763 0 : tevent_req_received(req);
37764 0 : return NT_STATUS_OK;
37765 : }
37766 :
37767 0 : NTSTATUS dcerpc_clusapi_CreateGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroupSet *r)
37768 : {
37769 : NTSTATUS status;
37770 :
37771 0 : status = dcerpc_binding_handle_call(h,
37772 : NULL, &ndr_table_clusapi,
37773 : NDR_CLUSAPI_CREATEGROUPSET, mem_ctx, r);
37774 :
37775 0 : return status;
37776 : }
37777 :
37778 : struct dcerpc_clusapi_CreateGroupSet_state {
37779 : struct clusapi_CreateGroupSet orig;
37780 : struct clusapi_CreateGroupSet tmp;
37781 : TALLOC_CTX *out_mem_ctx;
37782 : };
37783 :
37784 : static void dcerpc_clusapi_CreateGroupSet_done(struct tevent_req *subreq);
37785 :
37786 0 : struct tevent_req *dcerpc_clusapi_CreateGroupSet_send(TALLOC_CTX *mem_ctx,
37787 : struct tevent_context *ev,
37788 : struct dcerpc_binding_handle *h,
37789 : const char *_lpszGroupSetName /* [in] [charset(UTF16),ref] */,
37790 : WERROR *_Status /* [out] [ref] */,
37791 : WERROR *_rpc_status /* [out] [ref] */,
37792 : struct policy_handle *_hGroupSet /* [out] [ref] */)
37793 : {
37794 : struct tevent_req *req;
37795 : struct dcerpc_clusapi_CreateGroupSet_state *state;
37796 : struct tevent_req *subreq;
37797 :
37798 0 : req = tevent_req_create(mem_ctx, &state,
37799 : struct dcerpc_clusapi_CreateGroupSet_state);
37800 0 : if (req == NULL) {
37801 0 : return NULL;
37802 : }
37803 0 : state->out_mem_ctx = NULL;
37804 :
37805 : /* In parameters */
37806 0 : state->orig.in.lpszGroupSetName = _lpszGroupSetName;
37807 :
37808 : /* Out parameters */
37809 0 : state->orig.out.Status = _Status;
37810 0 : state->orig.out.rpc_status = _rpc_status;
37811 0 : state->orig.out.hGroupSet = _hGroupSet;
37812 :
37813 0 : state->out_mem_ctx = talloc_named_const(state, 0,
37814 : "dcerpc_clusapi_CreateGroupSet_out_memory");
37815 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
37816 0 : return tevent_req_post(req, ev);
37817 : }
37818 :
37819 : /* make a temporary copy, that we pass to the dispatch function */
37820 0 : state->tmp = state->orig;
37821 :
37822 0 : subreq = dcerpc_clusapi_CreateGroupSet_r_send(state, ev, h, &state->tmp);
37823 0 : if (tevent_req_nomem(subreq, req)) {
37824 0 : return tevent_req_post(req, ev);
37825 : }
37826 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupSet_done, req);
37827 0 : return req;
37828 : }
37829 :
37830 0 : static void dcerpc_clusapi_CreateGroupSet_done(struct tevent_req *subreq)
37831 : {
37832 0 : struct tevent_req *req = tevent_req_callback_data(
37833 : subreq, struct tevent_req);
37834 0 : struct dcerpc_clusapi_CreateGroupSet_state *state = tevent_req_data(
37835 : req, struct dcerpc_clusapi_CreateGroupSet_state);
37836 : NTSTATUS status;
37837 : TALLOC_CTX *mem_ctx;
37838 :
37839 0 : if (state->out_mem_ctx) {
37840 0 : mem_ctx = state->out_mem_ctx;
37841 : } else {
37842 0 : mem_ctx = state;
37843 : }
37844 :
37845 0 : status = dcerpc_clusapi_CreateGroupSet_r_recv(subreq, mem_ctx);
37846 0 : TALLOC_FREE(subreq);
37847 0 : if (tevent_req_nterror(req, status)) {
37848 0 : return;
37849 : }
37850 :
37851 : /* Copy out parameters */
37852 0 : *state->orig.out.Status = *state->tmp.out.Status;
37853 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
37854 0 : *state->orig.out.hGroupSet = *state->tmp.out.hGroupSet;
37855 :
37856 : /* Reset temporary structure */
37857 0 : NDR_ZERO_STRUCT(state->tmp);
37858 :
37859 0 : tevent_req_done(req);
37860 : }
37861 :
37862 0 : NTSTATUS dcerpc_clusapi_CreateGroupSet_recv(struct tevent_req *req,
37863 : TALLOC_CTX *mem_ctx)
37864 : {
37865 0 : struct dcerpc_clusapi_CreateGroupSet_state *state = tevent_req_data(
37866 : req, struct dcerpc_clusapi_CreateGroupSet_state);
37867 : NTSTATUS status;
37868 :
37869 0 : if (tevent_req_is_nterror(req, &status)) {
37870 0 : tevent_req_received(req);
37871 0 : return status;
37872 : }
37873 :
37874 : /* Steal possible out parameters to the callers context */
37875 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37876 :
37877 0 : tevent_req_received(req);
37878 0 : return NT_STATUS_OK;
37879 : }
37880 :
37881 0 : NTSTATUS dcerpc_clusapi_CreateGroupSet(struct dcerpc_binding_handle *h,
37882 : TALLOC_CTX *mem_ctx,
37883 : const char *_lpszGroupSetName /* [in] [charset(UTF16),ref] */,
37884 : WERROR *_Status /* [out] [ref] */,
37885 : WERROR *_rpc_status /* [out] [ref] */,
37886 : struct policy_handle *_hGroupSet /* [out] [ref] */)
37887 : {
37888 : struct clusapi_CreateGroupSet r;
37889 : NTSTATUS status;
37890 :
37891 : /* In parameters */
37892 0 : r.in.lpszGroupSetName = _lpszGroupSetName;
37893 :
37894 : /* Out parameters */
37895 0 : r.out.Status = _Status;
37896 0 : r.out.rpc_status = _rpc_status;
37897 0 : r.out.hGroupSet = _hGroupSet;
37898 :
37899 0 : status = dcerpc_clusapi_CreateGroupSet_r(h, mem_ctx, &r);
37900 0 : if (!NT_STATUS_IS_OK(status)) {
37901 0 : return status;
37902 : }
37903 :
37904 : /* Return variables */
37905 0 : *_Status = *r.out.Status;
37906 0 : *_rpc_status = *r.out.rpc_status;
37907 0 : *_hGroupSet = *r.out.hGroupSet;
37908 :
37909 : /* Return result */
37910 :
37911 0 : return NT_STATUS_OK;
37912 : }
37913 :
37914 : struct dcerpc_clusapi_OpenGroupSet_r_state {
37915 : TALLOC_CTX *out_mem_ctx;
37916 : };
37917 :
37918 : static void dcerpc_clusapi_OpenGroupSet_r_done(struct tevent_req *subreq);
37919 :
37920 0 : struct tevent_req *dcerpc_clusapi_OpenGroupSet_r_send(TALLOC_CTX *mem_ctx,
37921 : struct tevent_context *ev,
37922 : struct dcerpc_binding_handle *h,
37923 : struct clusapi_OpenGroupSet *r)
37924 : {
37925 : struct tevent_req *req;
37926 : struct dcerpc_clusapi_OpenGroupSet_r_state *state;
37927 : struct tevent_req *subreq;
37928 :
37929 0 : req = tevent_req_create(mem_ctx, &state,
37930 : struct dcerpc_clusapi_OpenGroupSet_r_state);
37931 0 : if (req == NULL) {
37932 0 : return NULL;
37933 : }
37934 :
37935 0 : state->out_mem_ctx = talloc_new(state);
37936 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
37937 0 : return tevent_req_post(req, ev);
37938 : }
37939 :
37940 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
37941 : NULL, &ndr_table_clusapi,
37942 0 : NDR_CLUSAPI_OPENGROUPSET, state->out_mem_ctx, r);
37943 0 : if (tevent_req_nomem(subreq, req)) {
37944 0 : return tevent_req_post(req, ev);
37945 : }
37946 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroupSet_r_done, req);
37947 :
37948 0 : return req;
37949 : }
37950 :
37951 0 : static void dcerpc_clusapi_OpenGroupSet_r_done(struct tevent_req *subreq)
37952 : {
37953 0 : struct tevent_req *req =
37954 0 : tevent_req_callback_data(subreq,
37955 : struct tevent_req);
37956 : NTSTATUS status;
37957 :
37958 0 : status = dcerpc_binding_handle_call_recv(subreq);
37959 0 : TALLOC_FREE(subreq);
37960 0 : if (tevent_req_nterror(req, status)) {
37961 0 : return;
37962 : }
37963 :
37964 0 : tevent_req_done(req);
37965 : }
37966 :
37967 0 : NTSTATUS dcerpc_clusapi_OpenGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
37968 : {
37969 0 : struct dcerpc_clusapi_OpenGroupSet_r_state *state =
37970 0 : tevent_req_data(req,
37971 : struct dcerpc_clusapi_OpenGroupSet_r_state);
37972 : NTSTATUS status;
37973 :
37974 0 : if (tevent_req_is_nterror(req, &status)) {
37975 0 : tevent_req_received(req);
37976 0 : return status;
37977 : }
37978 :
37979 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
37980 :
37981 0 : tevent_req_received(req);
37982 0 : return NT_STATUS_OK;
37983 : }
37984 :
37985 0 : NTSTATUS dcerpc_clusapi_OpenGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_OpenGroupSet *r)
37986 : {
37987 : NTSTATUS status;
37988 :
37989 0 : status = dcerpc_binding_handle_call(h,
37990 : NULL, &ndr_table_clusapi,
37991 : NDR_CLUSAPI_OPENGROUPSET, mem_ctx, r);
37992 :
37993 0 : return status;
37994 : }
37995 :
37996 : struct dcerpc_clusapi_OpenGroupSet_state {
37997 : struct clusapi_OpenGroupSet orig;
37998 : struct clusapi_OpenGroupSet tmp;
37999 : TALLOC_CTX *out_mem_ctx;
38000 : };
38001 :
38002 : static void dcerpc_clusapi_OpenGroupSet_done(struct tevent_req *subreq);
38003 :
38004 0 : struct tevent_req *dcerpc_clusapi_OpenGroupSet_send(TALLOC_CTX *mem_ctx,
38005 : struct tevent_context *ev,
38006 : struct dcerpc_binding_handle *h,
38007 : const char *_lpszGroupSetName /* [in] [charset(UTF16),ref] */,
38008 : WERROR *_Status /* [out] [ref] */,
38009 : WERROR *_rpc_status /* [out] [ref] */,
38010 : struct policy_handle *_hGroupSet /* [out] [ref] */)
38011 : {
38012 : struct tevent_req *req;
38013 : struct dcerpc_clusapi_OpenGroupSet_state *state;
38014 : struct tevent_req *subreq;
38015 :
38016 0 : req = tevent_req_create(mem_ctx, &state,
38017 : struct dcerpc_clusapi_OpenGroupSet_state);
38018 0 : if (req == NULL) {
38019 0 : return NULL;
38020 : }
38021 0 : state->out_mem_ctx = NULL;
38022 :
38023 : /* In parameters */
38024 0 : state->orig.in.lpszGroupSetName = _lpszGroupSetName;
38025 :
38026 : /* Out parameters */
38027 0 : state->orig.out.Status = _Status;
38028 0 : state->orig.out.rpc_status = _rpc_status;
38029 0 : state->orig.out.hGroupSet = _hGroupSet;
38030 :
38031 0 : state->out_mem_ctx = talloc_named_const(state, 0,
38032 : "dcerpc_clusapi_OpenGroupSet_out_memory");
38033 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38034 0 : return tevent_req_post(req, ev);
38035 : }
38036 :
38037 : /* make a temporary copy, that we pass to the dispatch function */
38038 0 : state->tmp = state->orig;
38039 :
38040 0 : subreq = dcerpc_clusapi_OpenGroupSet_r_send(state, ev, h, &state->tmp);
38041 0 : if (tevent_req_nomem(subreq, req)) {
38042 0 : return tevent_req_post(req, ev);
38043 : }
38044 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_OpenGroupSet_done, req);
38045 0 : return req;
38046 : }
38047 :
38048 0 : static void dcerpc_clusapi_OpenGroupSet_done(struct tevent_req *subreq)
38049 : {
38050 0 : struct tevent_req *req = tevent_req_callback_data(
38051 : subreq, struct tevent_req);
38052 0 : struct dcerpc_clusapi_OpenGroupSet_state *state = tevent_req_data(
38053 : req, struct dcerpc_clusapi_OpenGroupSet_state);
38054 : NTSTATUS status;
38055 : TALLOC_CTX *mem_ctx;
38056 :
38057 0 : if (state->out_mem_ctx) {
38058 0 : mem_ctx = state->out_mem_ctx;
38059 : } else {
38060 0 : mem_ctx = state;
38061 : }
38062 :
38063 0 : status = dcerpc_clusapi_OpenGroupSet_r_recv(subreq, mem_ctx);
38064 0 : TALLOC_FREE(subreq);
38065 0 : if (tevent_req_nterror(req, status)) {
38066 0 : return;
38067 : }
38068 :
38069 : /* Copy out parameters */
38070 0 : *state->orig.out.Status = *state->tmp.out.Status;
38071 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
38072 0 : *state->orig.out.hGroupSet = *state->tmp.out.hGroupSet;
38073 :
38074 : /* Reset temporary structure */
38075 0 : NDR_ZERO_STRUCT(state->tmp);
38076 :
38077 0 : tevent_req_done(req);
38078 : }
38079 :
38080 0 : NTSTATUS dcerpc_clusapi_OpenGroupSet_recv(struct tevent_req *req,
38081 : TALLOC_CTX *mem_ctx)
38082 : {
38083 0 : struct dcerpc_clusapi_OpenGroupSet_state *state = tevent_req_data(
38084 : req, struct dcerpc_clusapi_OpenGroupSet_state);
38085 : NTSTATUS status;
38086 :
38087 0 : if (tevent_req_is_nterror(req, &status)) {
38088 0 : tevent_req_received(req);
38089 0 : return status;
38090 : }
38091 :
38092 : /* Steal possible out parameters to the callers context */
38093 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38094 :
38095 0 : tevent_req_received(req);
38096 0 : return NT_STATUS_OK;
38097 : }
38098 :
38099 0 : NTSTATUS dcerpc_clusapi_OpenGroupSet(struct dcerpc_binding_handle *h,
38100 : TALLOC_CTX *mem_ctx,
38101 : const char *_lpszGroupSetName /* [in] [charset(UTF16),ref] */,
38102 : WERROR *_Status /* [out] [ref] */,
38103 : WERROR *_rpc_status /* [out] [ref] */,
38104 : struct policy_handle *_hGroupSet /* [out] [ref] */)
38105 : {
38106 : struct clusapi_OpenGroupSet r;
38107 : NTSTATUS status;
38108 :
38109 : /* In parameters */
38110 0 : r.in.lpszGroupSetName = _lpszGroupSetName;
38111 :
38112 : /* Out parameters */
38113 0 : r.out.Status = _Status;
38114 0 : r.out.rpc_status = _rpc_status;
38115 0 : r.out.hGroupSet = _hGroupSet;
38116 :
38117 0 : status = dcerpc_clusapi_OpenGroupSet_r(h, mem_ctx, &r);
38118 0 : if (!NT_STATUS_IS_OK(status)) {
38119 0 : return status;
38120 : }
38121 :
38122 : /* Return variables */
38123 0 : *_Status = *r.out.Status;
38124 0 : *_rpc_status = *r.out.rpc_status;
38125 0 : *_hGroupSet = *r.out.hGroupSet;
38126 :
38127 : /* Return result */
38128 :
38129 0 : return NT_STATUS_OK;
38130 : }
38131 :
38132 : struct dcerpc_clusapi_CloseGroupSet_r_state {
38133 : TALLOC_CTX *out_mem_ctx;
38134 : };
38135 :
38136 : static void dcerpc_clusapi_CloseGroupSet_r_done(struct tevent_req *subreq);
38137 :
38138 0 : struct tevent_req *dcerpc_clusapi_CloseGroupSet_r_send(TALLOC_CTX *mem_ctx,
38139 : struct tevent_context *ev,
38140 : struct dcerpc_binding_handle *h,
38141 : struct clusapi_CloseGroupSet *r)
38142 : {
38143 : struct tevent_req *req;
38144 : struct dcerpc_clusapi_CloseGroupSet_r_state *state;
38145 : struct tevent_req *subreq;
38146 :
38147 0 : req = tevent_req_create(mem_ctx, &state,
38148 : struct dcerpc_clusapi_CloseGroupSet_r_state);
38149 0 : if (req == NULL) {
38150 0 : return NULL;
38151 : }
38152 :
38153 0 : state->out_mem_ctx = talloc_new(state);
38154 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38155 0 : return tevent_req_post(req, ev);
38156 : }
38157 :
38158 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
38159 : NULL, &ndr_table_clusapi,
38160 0 : NDR_CLUSAPI_CLOSEGROUPSET, state->out_mem_ctx, r);
38161 0 : if (tevent_req_nomem(subreq, req)) {
38162 0 : return tevent_req_post(req, ev);
38163 : }
38164 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseGroupSet_r_done, req);
38165 :
38166 0 : return req;
38167 : }
38168 :
38169 0 : static void dcerpc_clusapi_CloseGroupSet_r_done(struct tevent_req *subreq)
38170 : {
38171 0 : struct tevent_req *req =
38172 0 : tevent_req_callback_data(subreq,
38173 : struct tevent_req);
38174 : NTSTATUS status;
38175 :
38176 0 : status = dcerpc_binding_handle_call_recv(subreq);
38177 0 : TALLOC_FREE(subreq);
38178 0 : if (tevent_req_nterror(req, status)) {
38179 0 : return;
38180 : }
38181 :
38182 0 : tevent_req_done(req);
38183 : }
38184 :
38185 0 : NTSTATUS dcerpc_clusapi_CloseGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
38186 : {
38187 0 : struct dcerpc_clusapi_CloseGroupSet_r_state *state =
38188 0 : tevent_req_data(req,
38189 : struct dcerpc_clusapi_CloseGroupSet_r_state);
38190 : NTSTATUS status;
38191 :
38192 0 : if (tevent_req_is_nterror(req, &status)) {
38193 0 : tevent_req_received(req);
38194 0 : return status;
38195 : }
38196 :
38197 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38198 :
38199 0 : tevent_req_received(req);
38200 0 : return NT_STATUS_OK;
38201 : }
38202 :
38203 0 : NTSTATUS dcerpc_clusapi_CloseGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CloseGroupSet *r)
38204 : {
38205 : NTSTATUS status;
38206 :
38207 0 : status = dcerpc_binding_handle_call(h,
38208 : NULL, &ndr_table_clusapi,
38209 : NDR_CLUSAPI_CLOSEGROUPSET, mem_ctx, r);
38210 :
38211 0 : return status;
38212 : }
38213 :
38214 : struct dcerpc_clusapi_CloseGroupSet_state {
38215 : struct clusapi_CloseGroupSet orig;
38216 : struct clusapi_CloseGroupSet tmp;
38217 : TALLOC_CTX *out_mem_ctx;
38218 : };
38219 :
38220 : static void dcerpc_clusapi_CloseGroupSet_done(struct tevent_req *subreq);
38221 :
38222 0 : struct tevent_req *dcerpc_clusapi_CloseGroupSet_send(TALLOC_CTX *mem_ctx,
38223 : struct tevent_context *ev,
38224 : struct dcerpc_binding_handle *h,
38225 : struct policy_handle *_GroupSet /* [in,out] [ref] */)
38226 : {
38227 : struct tevent_req *req;
38228 : struct dcerpc_clusapi_CloseGroupSet_state *state;
38229 : struct tevent_req *subreq;
38230 :
38231 0 : req = tevent_req_create(mem_ctx, &state,
38232 : struct dcerpc_clusapi_CloseGroupSet_state);
38233 0 : if (req == NULL) {
38234 0 : return NULL;
38235 : }
38236 0 : state->out_mem_ctx = NULL;
38237 :
38238 : /* In parameters */
38239 0 : state->orig.in.GroupSet = _GroupSet;
38240 :
38241 : /* Out parameters */
38242 0 : state->orig.out.GroupSet = _GroupSet;
38243 :
38244 : /* Result */
38245 0 : NDR_ZERO_STRUCT(state->orig.out.result);
38246 :
38247 0 : state->out_mem_ctx = talloc_named_const(state, 0,
38248 : "dcerpc_clusapi_CloseGroupSet_out_memory");
38249 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38250 0 : return tevent_req_post(req, ev);
38251 : }
38252 :
38253 : /* make a temporary copy, that we pass to the dispatch function */
38254 0 : state->tmp = state->orig;
38255 :
38256 0 : subreq = dcerpc_clusapi_CloseGroupSet_r_send(state, ev, h, &state->tmp);
38257 0 : if (tevent_req_nomem(subreq, req)) {
38258 0 : return tevent_req_post(req, ev);
38259 : }
38260 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CloseGroupSet_done, req);
38261 0 : return req;
38262 : }
38263 :
38264 0 : static void dcerpc_clusapi_CloseGroupSet_done(struct tevent_req *subreq)
38265 : {
38266 0 : struct tevent_req *req = tevent_req_callback_data(
38267 : subreq, struct tevent_req);
38268 0 : struct dcerpc_clusapi_CloseGroupSet_state *state = tevent_req_data(
38269 : req, struct dcerpc_clusapi_CloseGroupSet_state);
38270 : NTSTATUS status;
38271 : TALLOC_CTX *mem_ctx;
38272 :
38273 0 : if (state->out_mem_ctx) {
38274 0 : mem_ctx = state->out_mem_ctx;
38275 : } else {
38276 0 : mem_ctx = state;
38277 : }
38278 :
38279 0 : status = dcerpc_clusapi_CloseGroupSet_r_recv(subreq, mem_ctx);
38280 0 : TALLOC_FREE(subreq);
38281 0 : if (tevent_req_nterror(req, status)) {
38282 0 : return;
38283 : }
38284 :
38285 : /* Copy out parameters */
38286 0 : *state->orig.out.GroupSet = *state->tmp.out.GroupSet;
38287 :
38288 : /* Copy result */
38289 0 : state->orig.out.result = state->tmp.out.result;
38290 :
38291 : /* Reset temporary structure */
38292 0 : NDR_ZERO_STRUCT(state->tmp);
38293 :
38294 0 : tevent_req_done(req);
38295 : }
38296 :
38297 0 : NTSTATUS dcerpc_clusapi_CloseGroupSet_recv(struct tevent_req *req,
38298 : TALLOC_CTX *mem_ctx,
38299 : WERROR *result)
38300 : {
38301 0 : struct dcerpc_clusapi_CloseGroupSet_state *state = tevent_req_data(
38302 : req, struct dcerpc_clusapi_CloseGroupSet_state);
38303 : NTSTATUS status;
38304 :
38305 0 : if (tevent_req_is_nterror(req, &status)) {
38306 0 : tevent_req_received(req);
38307 0 : return status;
38308 : }
38309 :
38310 : /* Steal possible out parameters to the callers context */
38311 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38312 :
38313 : /* Return result */
38314 0 : *result = state->orig.out.result;
38315 :
38316 0 : tevent_req_received(req);
38317 0 : return NT_STATUS_OK;
38318 : }
38319 :
38320 0 : NTSTATUS dcerpc_clusapi_CloseGroupSet(struct dcerpc_binding_handle *h,
38321 : TALLOC_CTX *mem_ctx,
38322 : struct policy_handle *_GroupSet /* [in,out] [ref] */,
38323 : WERROR *result)
38324 : {
38325 : struct clusapi_CloseGroupSet r;
38326 : NTSTATUS status;
38327 :
38328 : /* In parameters */
38329 0 : r.in.GroupSet = _GroupSet;
38330 :
38331 : /* Out parameters */
38332 0 : r.out.GroupSet = _GroupSet;
38333 :
38334 : /* Result */
38335 0 : NDR_ZERO_STRUCT(r.out.result);
38336 :
38337 0 : status = dcerpc_clusapi_CloseGroupSet_r(h, mem_ctx, &r);
38338 0 : if (!NT_STATUS_IS_OK(status)) {
38339 0 : return status;
38340 : }
38341 :
38342 : /* Return variables */
38343 0 : *_GroupSet = *r.out.GroupSet;
38344 :
38345 : /* Return result */
38346 0 : *result = r.out.result;
38347 :
38348 0 : return NT_STATUS_OK;
38349 : }
38350 :
38351 : struct dcerpc_clusapi_DeleteGroupSet_r_state {
38352 : TALLOC_CTX *out_mem_ctx;
38353 : };
38354 :
38355 : static void dcerpc_clusapi_DeleteGroupSet_r_done(struct tevent_req *subreq);
38356 :
38357 0 : struct tevent_req *dcerpc_clusapi_DeleteGroupSet_r_send(TALLOC_CTX *mem_ctx,
38358 : struct tevent_context *ev,
38359 : struct dcerpc_binding_handle *h,
38360 : struct clusapi_DeleteGroupSet *r)
38361 : {
38362 : struct tevent_req *req;
38363 : struct dcerpc_clusapi_DeleteGroupSet_r_state *state;
38364 : struct tevent_req *subreq;
38365 :
38366 0 : req = tevent_req_create(mem_ctx, &state,
38367 : struct dcerpc_clusapi_DeleteGroupSet_r_state);
38368 0 : if (req == NULL) {
38369 0 : return NULL;
38370 : }
38371 :
38372 0 : state->out_mem_ctx = talloc_new(state);
38373 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38374 0 : return tevent_req_post(req, ev);
38375 : }
38376 :
38377 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
38378 : NULL, &ndr_table_clusapi,
38379 0 : NDR_CLUSAPI_DELETEGROUPSET, state->out_mem_ctx, r);
38380 0 : if (tevent_req_nomem(subreq, req)) {
38381 0 : return tevent_req_post(req, ev);
38382 : }
38383 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteGroupSet_r_done, req);
38384 :
38385 0 : return req;
38386 : }
38387 :
38388 0 : static void dcerpc_clusapi_DeleteGroupSet_r_done(struct tevent_req *subreq)
38389 : {
38390 0 : struct tevent_req *req =
38391 0 : tevent_req_callback_data(subreq,
38392 : struct tevent_req);
38393 : NTSTATUS status;
38394 :
38395 0 : status = dcerpc_binding_handle_call_recv(subreq);
38396 0 : TALLOC_FREE(subreq);
38397 0 : if (tevent_req_nterror(req, status)) {
38398 0 : return;
38399 : }
38400 :
38401 0 : tevent_req_done(req);
38402 : }
38403 :
38404 0 : NTSTATUS dcerpc_clusapi_DeleteGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
38405 : {
38406 0 : struct dcerpc_clusapi_DeleteGroupSet_r_state *state =
38407 0 : tevent_req_data(req,
38408 : struct dcerpc_clusapi_DeleteGroupSet_r_state);
38409 : NTSTATUS status;
38410 :
38411 0 : if (tevent_req_is_nterror(req, &status)) {
38412 0 : tevent_req_received(req);
38413 0 : return status;
38414 : }
38415 :
38416 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38417 :
38418 0 : tevent_req_received(req);
38419 0 : return NT_STATUS_OK;
38420 : }
38421 :
38422 0 : NTSTATUS dcerpc_clusapi_DeleteGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_DeleteGroupSet *r)
38423 : {
38424 : NTSTATUS status;
38425 :
38426 0 : status = dcerpc_binding_handle_call(h,
38427 : NULL, &ndr_table_clusapi,
38428 : NDR_CLUSAPI_DELETEGROUPSET, mem_ctx, r);
38429 :
38430 0 : return status;
38431 : }
38432 :
38433 : struct dcerpc_clusapi_DeleteGroupSet_state {
38434 : struct clusapi_DeleteGroupSet orig;
38435 : struct clusapi_DeleteGroupSet tmp;
38436 : TALLOC_CTX *out_mem_ctx;
38437 : };
38438 :
38439 : static void dcerpc_clusapi_DeleteGroupSet_done(struct tevent_req *subreq);
38440 :
38441 0 : struct tevent_req *dcerpc_clusapi_DeleteGroupSet_send(TALLOC_CTX *mem_ctx,
38442 : struct tevent_context *ev,
38443 : struct dcerpc_binding_handle *h,
38444 : struct policy_handle _GroupSet /* [in] */,
38445 : WERROR *_rpc_status /* [out] [ref] */)
38446 : {
38447 : struct tevent_req *req;
38448 : struct dcerpc_clusapi_DeleteGroupSet_state *state;
38449 : struct tevent_req *subreq;
38450 :
38451 0 : req = tevent_req_create(mem_ctx, &state,
38452 : struct dcerpc_clusapi_DeleteGroupSet_state);
38453 0 : if (req == NULL) {
38454 0 : return NULL;
38455 : }
38456 0 : state->out_mem_ctx = NULL;
38457 :
38458 : /* In parameters */
38459 0 : state->orig.in.GroupSet = _GroupSet;
38460 :
38461 : /* Out parameters */
38462 0 : state->orig.out.rpc_status = _rpc_status;
38463 :
38464 : /* Result */
38465 0 : NDR_ZERO_STRUCT(state->orig.out.result);
38466 :
38467 0 : state->out_mem_ctx = talloc_named_const(state, 0,
38468 : "dcerpc_clusapi_DeleteGroupSet_out_memory");
38469 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38470 0 : return tevent_req_post(req, ev);
38471 : }
38472 :
38473 : /* make a temporary copy, that we pass to the dispatch function */
38474 0 : state->tmp = state->orig;
38475 :
38476 0 : subreq = dcerpc_clusapi_DeleteGroupSet_r_send(state, ev, h, &state->tmp);
38477 0 : if (tevent_req_nomem(subreq, req)) {
38478 0 : return tevent_req_post(req, ev);
38479 : }
38480 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_DeleteGroupSet_done, req);
38481 0 : return req;
38482 : }
38483 :
38484 0 : static void dcerpc_clusapi_DeleteGroupSet_done(struct tevent_req *subreq)
38485 : {
38486 0 : struct tevent_req *req = tevent_req_callback_data(
38487 : subreq, struct tevent_req);
38488 0 : struct dcerpc_clusapi_DeleteGroupSet_state *state = tevent_req_data(
38489 : req, struct dcerpc_clusapi_DeleteGroupSet_state);
38490 : NTSTATUS status;
38491 : TALLOC_CTX *mem_ctx;
38492 :
38493 0 : if (state->out_mem_ctx) {
38494 0 : mem_ctx = state->out_mem_ctx;
38495 : } else {
38496 0 : mem_ctx = state;
38497 : }
38498 :
38499 0 : status = dcerpc_clusapi_DeleteGroupSet_r_recv(subreq, mem_ctx);
38500 0 : TALLOC_FREE(subreq);
38501 0 : if (tevent_req_nterror(req, status)) {
38502 0 : return;
38503 : }
38504 :
38505 : /* Copy out parameters */
38506 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
38507 :
38508 : /* Copy result */
38509 0 : state->orig.out.result = state->tmp.out.result;
38510 :
38511 : /* Reset temporary structure */
38512 0 : NDR_ZERO_STRUCT(state->tmp);
38513 :
38514 0 : tevent_req_done(req);
38515 : }
38516 :
38517 0 : NTSTATUS dcerpc_clusapi_DeleteGroupSet_recv(struct tevent_req *req,
38518 : TALLOC_CTX *mem_ctx,
38519 : WERROR *result)
38520 : {
38521 0 : struct dcerpc_clusapi_DeleteGroupSet_state *state = tevent_req_data(
38522 : req, struct dcerpc_clusapi_DeleteGroupSet_state);
38523 : NTSTATUS status;
38524 :
38525 0 : if (tevent_req_is_nterror(req, &status)) {
38526 0 : tevent_req_received(req);
38527 0 : return status;
38528 : }
38529 :
38530 : /* Steal possible out parameters to the callers context */
38531 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38532 :
38533 : /* Return result */
38534 0 : *result = state->orig.out.result;
38535 :
38536 0 : tevent_req_received(req);
38537 0 : return NT_STATUS_OK;
38538 : }
38539 :
38540 0 : NTSTATUS dcerpc_clusapi_DeleteGroupSet(struct dcerpc_binding_handle *h,
38541 : TALLOC_CTX *mem_ctx,
38542 : struct policy_handle _GroupSet /* [in] */,
38543 : WERROR *_rpc_status /* [out] [ref] */,
38544 : WERROR *result)
38545 : {
38546 : struct clusapi_DeleteGroupSet r;
38547 : NTSTATUS status;
38548 :
38549 : /* In parameters */
38550 0 : r.in.GroupSet = _GroupSet;
38551 :
38552 : /* Out parameters */
38553 0 : r.out.rpc_status = _rpc_status;
38554 :
38555 : /* Result */
38556 0 : NDR_ZERO_STRUCT(r.out.result);
38557 :
38558 0 : status = dcerpc_clusapi_DeleteGroupSet_r(h, mem_ctx, &r);
38559 0 : if (!NT_STATUS_IS_OK(status)) {
38560 0 : return status;
38561 : }
38562 :
38563 : /* Return variables */
38564 0 : *_rpc_status = *r.out.rpc_status;
38565 :
38566 : /* Return result */
38567 0 : *result = r.out.result;
38568 :
38569 0 : return NT_STATUS_OK;
38570 : }
38571 :
38572 : struct dcerpc_clusapi_AddGroupToGroupSet_r_state {
38573 : TALLOC_CTX *out_mem_ctx;
38574 : };
38575 :
38576 : static void dcerpc_clusapi_AddGroupToGroupSet_r_done(struct tevent_req *subreq);
38577 :
38578 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSet_r_send(TALLOC_CTX *mem_ctx,
38579 : struct tevent_context *ev,
38580 : struct dcerpc_binding_handle *h,
38581 : struct clusapi_AddGroupToGroupSet *r)
38582 : {
38583 : struct tevent_req *req;
38584 : struct dcerpc_clusapi_AddGroupToGroupSet_r_state *state;
38585 : struct tevent_req *subreq;
38586 :
38587 0 : req = tevent_req_create(mem_ctx, &state,
38588 : struct dcerpc_clusapi_AddGroupToGroupSet_r_state);
38589 0 : if (req == NULL) {
38590 0 : return NULL;
38591 : }
38592 :
38593 0 : state->out_mem_ctx = talloc_new(state);
38594 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38595 0 : return tevent_req_post(req, ev);
38596 : }
38597 :
38598 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
38599 : NULL, &ndr_table_clusapi,
38600 0 : NDR_CLUSAPI_ADDGROUPTOGROUPSET, state->out_mem_ctx, r);
38601 0 : if (tevent_req_nomem(subreq, req)) {
38602 0 : return tevent_req_post(req, ev);
38603 : }
38604 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSet_r_done, req);
38605 :
38606 0 : return req;
38607 : }
38608 :
38609 0 : static void dcerpc_clusapi_AddGroupToGroupSet_r_done(struct tevent_req *subreq)
38610 : {
38611 0 : struct tevent_req *req =
38612 0 : tevent_req_callback_data(subreq,
38613 : struct tevent_req);
38614 : NTSTATUS status;
38615 :
38616 0 : status = dcerpc_binding_handle_call_recv(subreq);
38617 0 : TALLOC_FREE(subreq);
38618 0 : if (tevent_req_nterror(req, status)) {
38619 0 : return;
38620 : }
38621 :
38622 0 : tevent_req_done(req);
38623 : }
38624 :
38625 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
38626 : {
38627 0 : struct dcerpc_clusapi_AddGroupToGroupSet_r_state *state =
38628 0 : tevent_req_data(req,
38629 : struct dcerpc_clusapi_AddGroupToGroupSet_r_state);
38630 : NTSTATUS status;
38631 :
38632 0 : if (tevent_req_is_nterror(req, &status)) {
38633 0 : tevent_req_received(req);
38634 0 : return status;
38635 : }
38636 :
38637 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38638 :
38639 0 : tevent_req_received(req);
38640 0 : return NT_STATUS_OK;
38641 : }
38642 :
38643 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddGroupToGroupSet *r)
38644 : {
38645 : NTSTATUS status;
38646 :
38647 0 : status = dcerpc_binding_handle_call(h,
38648 : NULL, &ndr_table_clusapi,
38649 : NDR_CLUSAPI_ADDGROUPTOGROUPSET, mem_ctx, r);
38650 :
38651 0 : return status;
38652 : }
38653 :
38654 : struct dcerpc_clusapi_AddGroupToGroupSet_state {
38655 : struct clusapi_AddGroupToGroupSet orig;
38656 : struct clusapi_AddGroupToGroupSet tmp;
38657 : TALLOC_CTX *out_mem_ctx;
38658 : };
38659 :
38660 : static void dcerpc_clusapi_AddGroupToGroupSet_done(struct tevent_req *subreq);
38661 :
38662 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSet_send(TALLOC_CTX *mem_ctx,
38663 : struct tevent_context *ev,
38664 : struct dcerpc_binding_handle *h,
38665 : struct policy_handle _GroupSet /* [in] */,
38666 : struct policy_handle _Group /* [in] */,
38667 : WERROR *_rpc_status /* [out] [ref] */)
38668 : {
38669 : struct tevent_req *req;
38670 : struct dcerpc_clusapi_AddGroupToGroupSet_state *state;
38671 : struct tevent_req *subreq;
38672 :
38673 0 : req = tevent_req_create(mem_ctx, &state,
38674 : struct dcerpc_clusapi_AddGroupToGroupSet_state);
38675 0 : if (req == NULL) {
38676 0 : return NULL;
38677 : }
38678 0 : state->out_mem_ctx = NULL;
38679 :
38680 : /* In parameters */
38681 0 : state->orig.in.GroupSet = _GroupSet;
38682 0 : state->orig.in.Group = _Group;
38683 :
38684 : /* Out parameters */
38685 0 : state->orig.out.rpc_status = _rpc_status;
38686 :
38687 : /* Result */
38688 0 : NDR_ZERO_STRUCT(state->orig.out.result);
38689 :
38690 0 : state->out_mem_ctx = talloc_named_const(state, 0,
38691 : "dcerpc_clusapi_AddGroupToGroupSet_out_memory");
38692 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38693 0 : return tevent_req_post(req, ev);
38694 : }
38695 :
38696 : /* make a temporary copy, that we pass to the dispatch function */
38697 0 : state->tmp = state->orig;
38698 :
38699 0 : subreq = dcerpc_clusapi_AddGroupToGroupSet_r_send(state, ev, h, &state->tmp);
38700 0 : if (tevent_req_nomem(subreq, req)) {
38701 0 : return tevent_req_post(req, ev);
38702 : }
38703 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSet_done, req);
38704 0 : return req;
38705 : }
38706 :
38707 0 : static void dcerpc_clusapi_AddGroupToGroupSet_done(struct tevent_req *subreq)
38708 : {
38709 0 : struct tevent_req *req = tevent_req_callback_data(
38710 : subreq, struct tevent_req);
38711 0 : struct dcerpc_clusapi_AddGroupToGroupSet_state *state = tevent_req_data(
38712 : req, struct dcerpc_clusapi_AddGroupToGroupSet_state);
38713 : NTSTATUS status;
38714 : TALLOC_CTX *mem_ctx;
38715 :
38716 0 : if (state->out_mem_ctx) {
38717 0 : mem_ctx = state->out_mem_ctx;
38718 : } else {
38719 0 : mem_ctx = state;
38720 : }
38721 :
38722 0 : status = dcerpc_clusapi_AddGroupToGroupSet_r_recv(subreq, mem_ctx);
38723 0 : TALLOC_FREE(subreq);
38724 0 : if (tevent_req_nterror(req, status)) {
38725 0 : return;
38726 : }
38727 :
38728 : /* Copy out parameters */
38729 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
38730 :
38731 : /* Copy result */
38732 0 : state->orig.out.result = state->tmp.out.result;
38733 :
38734 : /* Reset temporary structure */
38735 0 : NDR_ZERO_STRUCT(state->tmp);
38736 :
38737 0 : tevent_req_done(req);
38738 : }
38739 :
38740 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSet_recv(struct tevent_req *req,
38741 : TALLOC_CTX *mem_ctx,
38742 : WERROR *result)
38743 : {
38744 0 : struct dcerpc_clusapi_AddGroupToGroupSet_state *state = tevent_req_data(
38745 : req, struct dcerpc_clusapi_AddGroupToGroupSet_state);
38746 : NTSTATUS status;
38747 :
38748 0 : if (tevent_req_is_nterror(req, &status)) {
38749 0 : tevent_req_received(req);
38750 0 : return status;
38751 : }
38752 :
38753 : /* Steal possible out parameters to the callers context */
38754 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38755 :
38756 : /* Return result */
38757 0 : *result = state->orig.out.result;
38758 :
38759 0 : tevent_req_received(req);
38760 0 : return NT_STATUS_OK;
38761 : }
38762 :
38763 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSet(struct dcerpc_binding_handle *h,
38764 : TALLOC_CTX *mem_ctx,
38765 : struct policy_handle _GroupSet /* [in] */,
38766 : struct policy_handle _Group /* [in] */,
38767 : WERROR *_rpc_status /* [out] [ref] */,
38768 : WERROR *result)
38769 : {
38770 : struct clusapi_AddGroupToGroupSet r;
38771 : NTSTATUS status;
38772 :
38773 : /* In parameters */
38774 0 : r.in.GroupSet = _GroupSet;
38775 0 : r.in.Group = _Group;
38776 :
38777 : /* Out parameters */
38778 0 : r.out.rpc_status = _rpc_status;
38779 :
38780 : /* Result */
38781 0 : NDR_ZERO_STRUCT(r.out.result);
38782 :
38783 0 : status = dcerpc_clusapi_AddGroupToGroupSet_r(h, mem_ctx, &r);
38784 0 : if (!NT_STATUS_IS_OK(status)) {
38785 0 : return status;
38786 : }
38787 :
38788 : /* Return variables */
38789 0 : *_rpc_status = *r.out.rpc_status;
38790 :
38791 : /* Return result */
38792 0 : *result = r.out.result;
38793 :
38794 0 : return NT_STATUS_OK;
38795 : }
38796 :
38797 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_r_state {
38798 : TALLOC_CTX *out_mem_ctx;
38799 : };
38800 :
38801 : static void dcerpc_clusapi_RemoveGroupFromGroupSet_r_done(struct tevent_req *subreq);
38802 :
38803 0 : struct tevent_req *dcerpc_clusapi_RemoveGroupFromGroupSet_r_send(TALLOC_CTX *mem_ctx,
38804 : struct tevent_context *ev,
38805 : struct dcerpc_binding_handle *h,
38806 : struct clusapi_RemoveGroupFromGroupSet *r)
38807 : {
38808 : struct tevent_req *req;
38809 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_r_state *state;
38810 : struct tevent_req *subreq;
38811 :
38812 0 : req = tevent_req_create(mem_ctx, &state,
38813 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_r_state);
38814 0 : if (req == NULL) {
38815 0 : return NULL;
38816 : }
38817 :
38818 0 : state->out_mem_ctx = talloc_new(state);
38819 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38820 0 : return tevent_req_post(req, ev);
38821 : }
38822 :
38823 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
38824 : NULL, &ndr_table_clusapi,
38825 0 : NDR_CLUSAPI_REMOVEGROUPFROMGROUPSET, state->out_mem_ctx, r);
38826 0 : if (tevent_req_nomem(subreq, req)) {
38827 0 : return tevent_req_post(req, ev);
38828 : }
38829 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveGroupFromGroupSet_r_done, req);
38830 :
38831 0 : return req;
38832 : }
38833 :
38834 0 : static void dcerpc_clusapi_RemoveGroupFromGroupSet_r_done(struct tevent_req *subreq)
38835 : {
38836 0 : struct tevent_req *req =
38837 0 : tevent_req_callback_data(subreq,
38838 : struct tevent_req);
38839 : NTSTATUS status;
38840 :
38841 0 : status = dcerpc_binding_handle_call_recv(subreq);
38842 0 : TALLOC_FREE(subreq);
38843 0 : if (tevent_req_nterror(req, status)) {
38844 0 : return;
38845 : }
38846 :
38847 0 : tevent_req_done(req);
38848 : }
38849 :
38850 0 : NTSTATUS dcerpc_clusapi_RemoveGroupFromGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
38851 : {
38852 0 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_r_state *state =
38853 0 : tevent_req_data(req,
38854 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_r_state);
38855 : NTSTATUS status;
38856 :
38857 0 : if (tevent_req_is_nterror(req, &status)) {
38858 0 : tevent_req_received(req);
38859 0 : return status;
38860 : }
38861 :
38862 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38863 :
38864 0 : tevent_req_received(req);
38865 0 : return NT_STATUS_OK;
38866 : }
38867 :
38868 0 : NTSTATUS dcerpc_clusapi_RemoveGroupFromGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveGroupFromGroupSet *r)
38869 : {
38870 : NTSTATUS status;
38871 :
38872 0 : status = dcerpc_binding_handle_call(h,
38873 : NULL, &ndr_table_clusapi,
38874 : NDR_CLUSAPI_REMOVEGROUPFROMGROUPSET, mem_ctx, r);
38875 :
38876 0 : return status;
38877 : }
38878 :
38879 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_state {
38880 : struct clusapi_RemoveGroupFromGroupSet orig;
38881 : struct clusapi_RemoveGroupFromGroupSet tmp;
38882 : TALLOC_CTX *out_mem_ctx;
38883 : };
38884 :
38885 : static void dcerpc_clusapi_RemoveGroupFromGroupSet_done(struct tevent_req *subreq);
38886 :
38887 0 : struct tevent_req *dcerpc_clusapi_RemoveGroupFromGroupSet_send(TALLOC_CTX *mem_ctx,
38888 : struct tevent_context *ev,
38889 : struct dcerpc_binding_handle *h,
38890 : struct policy_handle _Group /* [in] */,
38891 : WERROR *_rpc_status /* [out] [ref] */)
38892 : {
38893 : struct tevent_req *req;
38894 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_state *state;
38895 : struct tevent_req *subreq;
38896 :
38897 0 : req = tevent_req_create(mem_ctx, &state,
38898 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_state);
38899 0 : if (req == NULL) {
38900 0 : return NULL;
38901 : }
38902 0 : state->out_mem_ctx = NULL;
38903 :
38904 : /* In parameters */
38905 0 : state->orig.in.Group = _Group;
38906 :
38907 : /* Out parameters */
38908 0 : state->orig.out.rpc_status = _rpc_status;
38909 :
38910 : /* Result */
38911 0 : NDR_ZERO_STRUCT(state->orig.out.result);
38912 :
38913 0 : state->out_mem_ctx = talloc_named_const(state, 0,
38914 : "dcerpc_clusapi_RemoveGroupFromGroupSet_out_memory");
38915 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
38916 0 : return tevent_req_post(req, ev);
38917 : }
38918 :
38919 : /* make a temporary copy, that we pass to the dispatch function */
38920 0 : state->tmp = state->orig;
38921 :
38922 0 : subreq = dcerpc_clusapi_RemoveGroupFromGroupSet_r_send(state, ev, h, &state->tmp);
38923 0 : if (tevent_req_nomem(subreq, req)) {
38924 0 : return tevent_req_post(req, ev);
38925 : }
38926 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveGroupFromGroupSet_done, req);
38927 0 : return req;
38928 : }
38929 :
38930 0 : static void dcerpc_clusapi_RemoveGroupFromGroupSet_done(struct tevent_req *subreq)
38931 : {
38932 0 : struct tevent_req *req = tevent_req_callback_data(
38933 : subreq, struct tevent_req);
38934 0 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_state *state = tevent_req_data(
38935 : req, struct dcerpc_clusapi_RemoveGroupFromGroupSet_state);
38936 : NTSTATUS status;
38937 : TALLOC_CTX *mem_ctx;
38938 :
38939 0 : if (state->out_mem_ctx) {
38940 0 : mem_ctx = state->out_mem_ctx;
38941 : } else {
38942 0 : mem_ctx = state;
38943 : }
38944 :
38945 0 : status = dcerpc_clusapi_RemoveGroupFromGroupSet_r_recv(subreq, mem_ctx);
38946 0 : TALLOC_FREE(subreq);
38947 0 : if (tevent_req_nterror(req, status)) {
38948 0 : return;
38949 : }
38950 :
38951 : /* Copy out parameters */
38952 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
38953 :
38954 : /* Copy result */
38955 0 : state->orig.out.result = state->tmp.out.result;
38956 :
38957 : /* Reset temporary structure */
38958 0 : NDR_ZERO_STRUCT(state->tmp);
38959 :
38960 0 : tevent_req_done(req);
38961 : }
38962 :
38963 0 : NTSTATUS dcerpc_clusapi_RemoveGroupFromGroupSet_recv(struct tevent_req *req,
38964 : TALLOC_CTX *mem_ctx,
38965 : WERROR *result)
38966 : {
38967 0 : struct dcerpc_clusapi_RemoveGroupFromGroupSet_state *state = tevent_req_data(
38968 : req, struct dcerpc_clusapi_RemoveGroupFromGroupSet_state);
38969 : NTSTATUS status;
38970 :
38971 0 : if (tevent_req_is_nterror(req, &status)) {
38972 0 : tevent_req_received(req);
38973 0 : return status;
38974 : }
38975 :
38976 : /* Steal possible out parameters to the callers context */
38977 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
38978 :
38979 : /* Return result */
38980 0 : *result = state->orig.out.result;
38981 :
38982 0 : tevent_req_received(req);
38983 0 : return NT_STATUS_OK;
38984 : }
38985 :
38986 0 : NTSTATUS dcerpc_clusapi_RemoveGroupFromGroupSet(struct dcerpc_binding_handle *h,
38987 : TALLOC_CTX *mem_ctx,
38988 : struct policy_handle _Group /* [in] */,
38989 : WERROR *_rpc_status /* [out] [ref] */,
38990 : WERROR *result)
38991 : {
38992 : struct clusapi_RemoveGroupFromGroupSet r;
38993 : NTSTATUS status;
38994 :
38995 : /* In parameters */
38996 0 : r.in.Group = _Group;
38997 :
38998 : /* Out parameters */
38999 0 : r.out.rpc_status = _rpc_status;
39000 :
39001 : /* Result */
39002 0 : NDR_ZERO_STRUCT(r.out.result);
39003 :
39004 0 : status = dcerpc_clusapi_RemoveGroupFromGroupSet_r(h, mem_ctx, &r);
39005 0 : if (!NT_STATUS_IS_OK(status)) {
39006 0 : return status;
39007 : }
39008 :
39009 : /* Return variables */
39010 0 : *_rpc_status = *r.out.rpc_status;
39011 :
39012 : /* Return result */
39013 0 : *result = r.out.result;
39014 :
39015 0 : return NT_STATUS_OK;
39016 : }
39017 :
39018 : struct dcerpc_clusapi_MoveGroupToGroupSet_r_state {
39019 : TALLOC_CTX *out_mem_ctx;
39020 : };
39021 :
39022 : static void dcerpc_clusapi_MoveGroupToGroupSet_r_done(struct tevent_req *subreq);
39023 :
39024 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToGroupSet_r_send(TALLOC_CTX *mem_ctx,
39025 : struct tevent_context *ev,
39026 : struct dcerpc_binding_handle *h,
39027 : struct clusapi_MoveGroupToGroupSet *r)
39028 : {
39029 : struct tevent_req *req;
39030 : struct dcerpc_clusapi_MoveGroupToGroupSet_r_state *state;
39031 : struct tevent_req *subreq;
39032 :
39033 0 : req = tevent_req_create(mem_ctx, &state,
39034 : struct dcerpc_clusapi_MoveGroupToGroupSet_r_state);
39035 0 : if (req == NULL) {
39036 0 : return NULL;
39037 : }
39038 :
39039 0 : state->out_mem_ctx = talloc_new(state);
39040 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39041 0 : return tevent_req_post(req, ev);
39042 : }
39043 :
39044 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
39045 : NULL, &ndr_table_clusapi,
39046 0 : NDR_CLUSAPI_MOVEGROUPTOGROUPSET, state->out_mem_ctx, r);
39047 0 : if (tevent_req_nomem(subreq, req)) {
39048 0 : return tevent_req_post(req, ev);
39049 : }
39050 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToGroupSet_r_done, req);
39051 :
39052 0 : return req;
39053 : }
39054 :
39055 0 : static void dcerpc_clusapi_MoveGroupToGroupSet_r_done(struct tevent_req *subreq)
39056 : {
39057 0 : struct tevent_req *req =
39058 0 : tevent_req_callback_data(subreq,
39059 : struct tevent_req);
39060 : NTSTATUS status;
39061 :
39062 0 : status = dcerpc_binding_handle_call_recv(subreq);
39063 0 : TALLOC_FREE(subreq);
39064 0 : if (tevent_req_nterror(req, status)) {
39065 0 : return;
39066 : }
39067 :
39068 0 : tevent_req_done(req);
39069 : }
39070 :
39071 0 : NTSTATUS dcerpc_clusapi_MoveGroupToGroupSet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
39072 : {
39073 0 : struct dcerpc_clusapi_MoveGroupToGroupSet_r_state *state =
39074 0 : tevent_req_data(req,
39075 : struct dcerpc_clusapi_MoveGroupToGroupSet_r_state);
39076 : NTSTATUS status;
39077 :
39078 0 : if (tevent_req_is_nterror(req, &status)) {
39079 0 : tevent_req_received(req);
39080 0 : return status;
39081 : }
39082 :
39083 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39084 :
39085 0 : tevent_req_received(req);
39086 0 : return NT_STATUS_OK;
39087 : }
39088 :
39089 0 : NTSTATUS dcerpc_clusapi_MoveGroupToGroupSet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_MoveGroupToGroupSet *r)
39090 : {
39091 : NTSTATUS status;
39092 :
39093 0 : status = dcerpc_binding_handle_call(h,
39094 : NULL, &ndr_table_clusapi,
39095 : NDR_CLUSAPI_MOVEGROUPTOGROUPSET, mem_ctx, r);
39096 :
39097 0 : return status;
39098 : }
39099 :
39100 : struct dcerpc_clusapi_MoveGroupToGroupSet_state {
39101 : struct clusapi_MoveGroupToGroupSet orig;
39102 : struct clusapi_MoveGroupToGroupSet tmp;
39103 : TALLOC_CTX *out_mem_ctx;
39104 : };
39105 :
39106 : static void dcerpc_clusapi_MoveGroupToGroupSet_done(struct tevent_req *subreq);
39107 :
39108 0 : struct tevent_req *dcerpc_clusapi_MoveGroupToGroupSet_send(TALLOC_CTX *mem_ctx,
39109 : struct tevent_context *ev,
39110 : struct dcerpc_binding_handle *h,
39111 : struct policy_handle _GroupSet /* [in] */,
39112 : struct policy_handle _Group /* [in] */,
39113 : WERROR *_rpc_status /* [out] [ref] */)
39114 : {
39115 : struct tevent_req *req;
39116 : struct dcerpc_clusapi_MoveGroupToGroupSet_state *state;
39117 : struct tevent_req *subreq;
39118 :
39119 0 : req = tevent_req_create(mem_ctx, &state,
39120 : struct dcerpc_clusapi_MoveGroupToGroupSet_state);
39121 0 : if (req == NULL) {
39122 0 : return NULL;
39123 : }
39124 0 : state->out_mem_ctx = NULL;
39125 :
39126 : /* In parameters */
39127 0 : state->orig.in.GroupSet = _GroupSet;
39128 0 : state->orig.in.Group = _Group;
39129 :
39130 : /* Out parameters */
39131 0 : state->orig.out.rpc_status = _rpc_status;
39132 :
39133 : /* Result */
39134 0 : NDR_ZERO_STRUCT(state->orig.out.result);
39135 :
39136 0 : state->out_mem_ctx = talloc_named_const(state, 0,
39137 : "dcerpc_clusapi_MoveGroupToGroupSet_out_memory");
39138 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39139 0 : return tevent_req_post(req, ev);
39140 : }
39141 :
39142 : /* make a temporary copy, that we pass to the dispatch function */
39143 0 : state->tmp = state->orig;
39144 :
39145 0 : subreq = dcerpc_clusapi_MoveGroupToGroupSet_r_send(state, ev, h, &state->tmp);
39146 0 : if (tevent_req_nomem(subreq, req)) {
39147 0 : return tevent_req_post(req, ev);
39148 : }
39149 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_MoveGroupToGroupSet_done, req);
39150 0 : return req;
39151 : }
39152 :
39153 0 : static void dcerpc_clusapi_MoveGroupToGroupSet_done(struct tevent_req *subreq)
39154 : {
39155 0 : struct tevent_req *req = tevent_req_callback_data(
39156 : subreq, struct tevent_req);
39157 0 : struct dcerpc_clusapi_MoveGroupToGroupSet_state *state = tevent_req_data(
39158 : req, struct dcerpc_clusapi_MoveGroupToGroupSet_state);
39159 : NTSTATUS status;
39160 : TALLOC_CTX *mem_ctx;
39161 :
39162 0 : if (state->out_mem_ctx) {
39163 0 : mem_ctx = state->out_mem_ctx;
39164 : } else {
39165 0 : mem_ctx = state;
39166 : }
39167 :
39168 0 : status = dcerpc_clusapi_MoveGroupToGroupSet_r_recv(subreq, mem_ctx);
39169 0 : TALLOC_FREE(subreq);
39170 0 : if (tevent_req_nterror(req, status)) {
39171 0 : return;
39172 : }
39173 :
39174 : /* Copy out parameters */
39175 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
39176 :
39177 : /* Copy result */
39178 0 : state->orig.out.result = state->tmp.out.result;
39179 :
39180 : /* Reset temporary structure */
39181 0 : NDR_ZERO_STRUCT(state->tmp);
39182 :
39183 0 : tevent_req_done(req);
39184 : }
39185 :
39186 0 : NTSTATUS dcerpc_clusapi_MoveGroupToGroupSet_recv(struct tevent_req *req,
39187 : TALLOC_CTX *mem_ctx,
39188 : WERROR *result)
39189 : {
39190 0 : struct dcerpc_clusapi_MoveGroupToGroupSet_state *state = tevent_req_data(
39191 : req, struct dcerpc_clusapi_MoveGroupToGroupSet_state);
39192 : NTSTATUS status;
39193 :
39194 0 : if (tevent_req_is_nterror(req, &status)) {
39195 0 : tevent_req_received(req);
39196 0 : return status;
39197 : }
39198 :
39199 : /* Steal possible out parameters to the callers context */
39200 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39201 :
39202 : /* Return result */
39203 0 : *result = state->orig.out.result;
39204 :
39205 0 : tevent_req_received(req);
39206 0 : return NT_STATUS_OK;
39207 : }
39208 :
39209 0 : NTSTATUS dcerpc_clusapi_MoveGroupToGroupSet(struct dcerpc_binding_handle *h,
39210 : TALLOC_CTX *mem_ctx,
39211 : struct policy_handle _GroupSet /* [in] */,
39212 : struct policy_handle _Group /* [in] */,
39213 : WERROR *_rpc_status /* [out] [ref] */,
39214 : WERROR *result)
39215 : {
39216 : struct clusapi_MoveGroupToGroupSet r;
39217 : NTSTATUS status;
39218 :
39219 : /* In parameters */
39220 0 : r.in.GroupSet = _GroupSet;
39221 0 : r.in.Group = _Group;
39222 :
39223 : /* Out parameters */
39224 0 : r.out.rpc_status = _rpc_status;
39225 :
39226 : /* Result */
39227 0 : NDR_ZERO_STRUCT(r.out.result);
39228 :
39229 0 : status = dcerpc_clusapi_MoveGroupToGroupSet_r(h, mem_ctx, &r);
39230 0 : if (!NT_STATUS_IS_OK(status)) {
39231 0 : return status;
39232 : }
39233 :
39234 : /* Return variables */
39235 0 : *_rpc_status = *r.out.rpc_status;
39236 :
39237 : /* Return result */
39238 0 : *result = r.out.result;
39239 :
39240 0 : return NT_STATUS_OK;
39241 : }
39242 :
39243 : struct dcerpc_Opnum170NotUsedOnWire_r_state {
39244 : TALLOC_CTX *out_mem_ctx;
39245 : };
39246 :
39247 : static void dcerpc_Opnum170NotUsedOnWire_r_done(struct tevent_req *subreq);
39248 :
39249 0 : struct tevent_req *dcerpc_Opnum170NotUsedOnWire_r_send(TALLOC_CTX *mem_ctx,
39250 : struct tevent_context *ev,
39251 : struct dcerpc_binding_handle *h,
39252 : struct Opnum170NotUsedOnWire *r)
39253 : {
39254 : struct tevent_req *req;
39255 : struct dcerpc_Opnum170NotUsedOnWire_r_state *state;
39256 : struct tevent_req *subreq;
39257 :
39258 0 : req = tevent_req_create(mem_ctx, &state,
39259 : struct dcerpc_Opnum170NotUsedOnWire_r_state);
39260 0 : if (req == NULL) {
39261 0 : return NULL;
39262 : }
39263 :
39264 0 : state->out_mem_ctx = NULL;
39265 :
39266 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
39267 : NULL, &ndr_table_clusapi,
39268 : NDR_OPNUM170NOTUSEDONWIRE, state, r);
39269 0 : if (tevent_req_nomem(subreq, req)) {
39270 0 : return tevent_req_post(req, ev);
39271 : }
39272 0 : tevent_req_set_callback(subreq, dcerpc_Opnum170NotUsedOnWire_r_done, req);
39273 :
39274 0 : return req;
39275 : }
39276 :
39277 0 : static void dcerpc_Opnum170NotUsedOnWire_r_done(struct tevent_req *subreq)
39278 : {
39279 0 : struct tevent_req *req =
39280 0 : tevent_req_callback_data(subreq,
39281 : struct tevent_req);
39282 : NTSTATUS status;
39283 :
39284 0 : status = dcerpc_binding_handle_call_recv(subreq);
39285 0 : TALLOC_FREE(subreq);
39286 0 : if (tevent_req_nterror(req, status)) {
39287 0 : return;
39288 : }
39289 :
39290 0 : tevent_req_done(req);
39291 : }
39292 :
39293 0 : NTSTATUS dcerpc_Opnum170NotUsedOnWire_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
39294 : {
39295 0 : struct dcerpc_Opnum170NotUsedOnWire_r_state *state =
39296 0 : tevent_req_data(req,
39297 : struct dcerpc_Opnum170NotUsedOnWire_r_state);
39298 : NTSTATUS status;
39299 :
39300 0 : if (tevent_req_is_nterror(req, &status)) {
39301 0 : tevent_req_received(req);
39302 0 : return status;
39303 : }
39304 :
39305 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39306 :
39307 0 : tevent_req_received(req);
39308 0 : return NT_STATUS_OK;
39309 : }
39310 :
39311 0 : NTSTATUS dcerpc_Opnum170NotUsedOnWire_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct Opnum170NotUsedOnWire *r)
39312 : {
39313 : NTSTATUS status;
39314 :
39315 0 : status = dcerpc_binding_handle_call(h,
39316 : NULL, &ndr_table_clusapi,
39317 : NDR_OPNUM170NOTUSEDONWIRE, mem_ctx, r);
39318 :
39319 0 : return status;
39320 : }
39321 :
39322 : struct dcerpc_Opnum170NotUsedOnWire_state {
39323 : struct Opnum170NotUsedOnWire orig;
39324 : struct Opnum170NotUsedOnWire tmp;
39325 : TALLOC_CTX *out_mem_ctx;
39326 : };
39327 :
39328 : static void dcerpc_Opnum170NotUsedOnWire_done(struct tevent_req *subreq);
39329 :
39330 0 : struct tevent_req *dcerpc_Opnum170NotUsedOnWire_send(TALLOC_CTX *mem_ctx,
39331 : struct tevent_context *ev,
39332 : struct dcerpc_binding_handle *h)
39333 : {
39334 : struct tevent_req *req;
39335 : struct dcerpc_Opnum170NotUsedOnWire_state *state;
39336 : struct tevent_req *subreq;
39337 :
39338 0 : req = tevent_req_create(mem_ctx, &state,
39339 : struct dcerpc_Opnum170NotUsedOnWire_state);
39340 0 : if (req == NULL) {
39341 0 : return NULL;
39342 : }
39343 0 : state->out_mem_ctx = NULL;
39344 :
39345 : /* In parameters */
39346 :
39347 : /* Out parameters */
39348 :
39349 : /* Result */
39350 0 : NDR_ZERO_STRUCT(state->orig.out.result);
39351 :
39352 : /* make a temporary copy, that we pass to the dispatch function */
39353 0 : state->tmp = state->orig;
39354 :
39355 0 : subreq = dcerpc_Opnum170NotUsedOnWire_r_send(state, ev, h, &state->tmp);
39356 0 : if (tevent_req_nomem(subreq, req)) {
39357 0 : return tevent_req_post(req, ev);
39358 : }
39359 0 : tevent_req_set_callback(subreq, dcerpc_Opnum170NotUsedOnWire_done, req);
39360 0 : return req;
39361 : }
39362 :
39363 0 : static void dcerpc_Opnum170NotUsedOnWire_done(struct tevent_req *subreq)
39364 : {
39365 0 : struct tevent_req *req = tevent_req_callback_data(
39366 : subreq, struct tevent_req);
39367 0 : struct dcerpc_Opnum170NotUsedOnWire_state *state = tevent_req_data(
39368 : req, struct dcerpc_Opnum170NotUsedOnWire_state);
39369 : NTSTATUS status;
39370 : TALLOC_CTX *mem_ctx;
39371 :
39372 0 : if (state->out_mem_ctx) {
39373 0 : mem_ctx = state->out_mem_ctx;
39374 : } else {
39375 0 : mem_ctx = state;
39376 : }
39377 :
39378 0 : status = dcerpc_Opnum170NotUsedOnWire_r_recv(subreq, mem_ctx);
39379 0 : TALLOC_FREE(subreq);
39380 0 : if (tevent_req_nterror(req, status)) {
39381 0 : return;
39382 : }
39383 :
39384 : /* Copy out parameters */
39385 :
39386 : /* Copy result */
39387 0 : state->orig.out.result = state->tmp.out.result;
39388 :
39389 : /* Reset temporary structure */
39390 0 : NDR_ZERO_STRUCT(state->tmp);
39391 :
39392 0 : tevent_req_done(req);
39393 : }
39394 :
39395 0 : NTSTATUS dcerpc_Opnum170NotUsedOnWire_recv(struct tevent_req *req,
39396 : TALLOC_CTX *mem_ctx,
39397 : WERROR *result)
39398 : {
39399 0 : struct dcerpc_Opnum170NotUsedOnWire_state *state = tevent_req_data(
39400 : req, struct dcerpc_Opnum170NotUsedOnWire_state);
39401 : NTSTATUS status;
39402 :
39403 0 : if (tevent_req_is_nterror(req, &status)) {
39404 0 : tevent_req_received(req);
39405 0 : return status;
39406 : }
39407 :
39408 : /* Steal possible out parameters to the callers context */
39409 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39410 :
39411 : /* Return result */
39412 0 : *result = state->orig.out.result;
39413 :
39414 0 : tevent_req_received(req);
39415 0 : return NT_STATUS_OK;
39416 : }
39417 :
39418 0 : NTSTATUS dcerpc_Opnum170NotUsedOnWire(struct dcerpc_binding_handle *h,
39419 : TALLOC_CTX *mem_ctx,
39420 : WERROR *result)
39421 : {
39422 : struct Opnum170NotUsedOnWire r;
39423 : NTSTATUS status;
39424 :
39425 : /* In parameters */
39426 :
39427 : /* Out parameters */
39428 :
39429 : /* Result */
39430 0 : NDR_ZERO_STRUCT(r.out.result);
39431 :
39432 0 : status = dcerpc_Opnum170NotUsedOnWire_r(h, mem_ctx, &r);
39433 0 : if (!NT_STATUS_IS_OK(status)) {
39434 0 : return status;
39435 : }
39436 :
39437 : /* Return variables */
39438 :
39439 : /* Return result */
39440 0 : *result = r.out.result;
39441 :
39442 0 : return NT_STATUS_OK;
39443 : }
39444 :
39445 : struct dcerpc_clusapi_AddGroupSetDependency_r_state {
39446 : TALLOC_CTX *out_mem_ctx;
39447 : };
39448 :
39449 : static void dcerpc_clusapi_AddGroupSetDependency_r_done(struct tevent_req *subreq);
39450 :
39451 0 : struct tevent_req *dcerpc_clusapi_AddGroupSetDependency_r_send(TALLOC_CTX *mem_ctx,
39452 : struct tevent_context *ev,
39453 : struct dcerpc_binding_handle *h,
39454 : struct clusapi_AddGroupSetDependency *r)
39455 : {
39456 : struct tevent_req *req;
39457 : struct dcerpc_clusapi_AddGroupSetDependency_r_state *state;
39458 : struct tevent_req *subreq;
39459 :
39460 0 : req = tevent_req_create(mem_ctx, &state,
39461 : struct dcerpc_clusapi_AddGroupSetDependency_r_state);
39462 0 : if (req == NULL) {
39463 0 : return NULL;
39464 : }
39465 :
39466 0 : state->out_mem_ctx = talloc_new(state);
39467 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39468 0 : return tevent_req_post(req, ev);
39469 : }
39470 :
39471 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
39472 : NULL, &ndr_table_clusapi,
39473 0 : NDR_CLUSAPI_ADDGROUPSETDEPENDENCY, state->out_mem_ctx, r);
39474 0 : if (tevent_req_nomem(subreq, req)) {
39475 0 : return tevent_req_post(req, ev);
39476 : }
39477 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupSetDependency_r_done, req);
39478 :
39479 0 : return req;
39480 : }
39481 :
39482 0 : static void dcerpc_clusapi_AddGroupSetDependency_r_done(struct tevent_req *subreq)
39483 : {
39484 0 : struct tevent_req *req =
39485 0 : tevent_req_callback_data(subreq,
39486 : struct tevent_req);
39487 : NTSTATUS status;
39488 :
39489 0 : status = dcerpc_binding_handle_call_recv(subreq);
39490 0 : TALLOC_FREE(subreq);
39491 0 : if (tevent_req_nterror(req, status)) {
39492 0 : return;
39493 : }
39494 :
39495 0 : tevent_req_done(req);
39496 : }
39497 :
39498 0 : NTSTATUS dcerpc_clusapi_AddGroupSetDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
39499 : {
39500 0 : struct dcerpc_clusapi_AddGroupSetDependency_r_state *state =
39501 0 : tevent_req_data(req,
39502 : struct dcerpc_clusapi_AddGroupSetDependency_r_state);
39503 : NTSTATUS status;
39504 :
39505 0 : if (tevent_req_is_nterror(req, &status)) {
39506 0 : tevent_req_received(req);
39507 0 : return status;
39508 : }
39509 :
39510 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39511 :
39512 0 : tevent_req_received(req);
39513 0 : return NT_STATUS_OK;
39514 : }
39515 :
39516 0 : NTSTATUS dcerpc_clusapi_AddGroupSetDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddGroupSetDependency *r)
39517 : {
39518 : NTSTATUS status;
39519 :
39520 0 : status = dcerpc_binding_handle_call(h,
39521 : NULL, &ndr_table_clusapi,
39522 : NDR_CLUSAPI_ADDGROUPSETDEPENDENCY, mem_ctx, r);
39523 :
39524 0 : return status;
39525 : }
39526 :
39527 : struct dcerpc_clusapi_AddGroupSetDependency_state {
39528 : struct clusapi_AddGroupSetDependency orig;
39529 : struct clusapi_AddGroupSetDependency tmp;
39530 : TALLOC_CTX *out_mem_ctx;
39531 : };
39532 :
39533 : static void dcerpc_clusapi_AddGroupSetDependency_done(struct tevent_req *subreq);
39534 :
39535 0 : struct tevent_req *dcerpc_clusapi_AddGroupSetDependency_send(TALLOC_CTX *mem_ctx,
39536 : struct tevent_context *ev,
39537 : struct dcerpc_binding_handle *h,
39538 : struct policy_handle _DependentGroupSet /* [in] */,
39539 : struct policy_handle _ProviderGroupSet /* [in] */,
39540 : WERROR *_rpc_status /* [out] [ref] */)
39541 : {
39542 : struct tevent_req *req;
39543 : struct dcerpc_clusapi_AddGroupSetDependency_state *state;
39544 : struct tevent_req *subreq;
39545 :
39546 0 : req = tevent_req_create(mem_ctx, &state,
39547 : struct dcerpc_clusapi_AddGroupSetDependency_state);
39548 0 : if (req == NULL) {
39549 0 : return NULL;
39550 : }
39551 0 : state->out_mem_ctx = NULL;
39552 :
39553 : /* In parameters */
39554 0 : state->orig.in.DependentGroupSet = _DependentGroupSet;
39555 0 : state->orig.in.ProviderGroupSet = _ProviderGroupSet;
39556 :
39557 : /* Out parameters */
39558 0 : state->orig.out.rpc_status = _rpc_status;
39559 :
39560 : /* Result */
39561 0 : NDR_ZERO_STRUCT(state->orig.out.result);
39562 :
39563 0 : state->out_mem_ctx = talloc_named_const(state, 0,
39564 : "dcerpc_clusapi_AddGroupSetDependency_out_memory");
39565 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39566 0 : return tevent_req_post(req, ev);
39567 : }
39568 :
39569 : /* make a temporary copy, that we pass to the dispatch function */
39570 0 : state->tmp = state->orig;
39571 :
39572 0 : subreq = dcerpc_clusapi_AddGroupSetDependency_r_send(state, ev, h, &state->tmp);
39573 0 : if (tevent_req_nomem(subreq, req)) {
39574 0 : return tevent_req_post(req, ev);
39575 : }
39576 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupSetDependency_done, req);
39577 0 : return req;
39578 : }
39579 :
39580 0 : static void dcerpc_clusapi_AddGroupSetDependency_done(struct tevent_req *subreq)
39581 : {
39582 0 : struct tevent_req *req = tevent_req_callback_data(
39583 : subreq, struct tevent_req);
39584 0 : struct dcerpc_clusapi_AddGroupSetDependency_state *state = tevent_req_data(
39585 : req, struct dcerpc_clusapi_AddGroupSetDependency_state);
39586 : NTSTATUS status;
39587 : TALLOC_CTX *mem_ctx;
39588 :
39589 0 : if (state->out_mem_ctx) {
39590 0 : mem_ctx = state->out_mem_ctx;
39591 : } else {
39592 0 : mem_ctx = state;
39593 : }
39594 :
39595 0 : status = dcerpc_clusapi_AddGroupSetDependency_r_recv(subreq, mem_ctx);
39596 0 : TALLOC_FREE(subreq);
39597 0 : if (tevent_req_nterror(req, status)) {
39598 0 : return;
39599 : }
39600 :
39601 : /* Copy out parameters */
39602 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
39603 :
39604 : /* Copy result */
39605 0 : state->orig.out.result = state->tmp.out.result;
39606 :
39607 : /* Reset temporary structure */
39608 0 : NDR_ZERO_STRUCT(state->tmp);
39609 :
39610 0 : tevent_req_done(req);
39611 : }
39612 :
39613 0 : NTSTATUS dcerpc_clusapi_AddGroupSetDependency_recv(struct tevent_req *req,
39614 : TALLOC_CTX *mem_ctx,
39615 : WERROR *result)
39616 : {
39617 0 : struct dcerpc_clusapi_AddGroupSetDependency_state *state = tevent_req_data(
39618 : req, struct dcerpc_clusapi_AddGroupSetDependency_state);
39619 : NTSTATUS status;
39620 :
39621 0 : if (tevent_req_is_nterror(req, &status)) {
39622 0 : tevent_req_received(req);
39623 0 : return status;
39624 : }
39625 :
39626 : /* Steal possible out parameters to the callers context */
39627 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39628 :
39629 : /* Return result */
39630 0 : *result = state->orig.out.result;
39631 :
39632 0 : tevent_req_received(req);
39633 0 : return NT_STATUS_OK;
39634 : }
39635 :
39636 0 : NTSTATUS dcerpc_clusapi_AddGroupSetDependency(struct dcerpc_binding_handle *h,
39637 : TALLOC_CTX *mem_ctx,
39638 : struct policy_handle _DependentGroupSet /* [in] */,
39639 : struct policy_handle _ProviderGroupSet /* [in] */,
39640 : WERROR *_rpc_status /* [out] [ref] */,
39641 : WERROR *result)
39642 : {
39643 : struct clusapi_AddGroupSetDependency r;
39644 : NTSTATUS status;
39645 :
39646 : /* In parameters */
39647 0 : r.in.DependentGroupSet = _DependentGroupSet;
39648 0 : r.in.ProviderGroupSet = _ProviderGroupSet;
39649 :
39650 : /* Out parameters */
39651 0 : r.out.rpc_status = _rpc_status;
39652 :
39653 : /* Result */
39654 0 : NDR_ZERO_STRUCT(r.out.result);
39655 :
39656 0 : status = dcerpc_clusapi_AddGroupSetDependency_r(h, mem_ctx, &r);
39657 0 : if (!NT_STATUS_IS_OK(status)) {
39658 0 : return status;
39659 : }
39660 :
39661 : /* Return variables */
39662 0 : *_rpc_status = *r.out.rpc_status;
39663 :
39664 : /* Return result */
39665 0 : *result = r.out.result;
39666 :
39667 0 : return NT_STATUS_OK;
39668 : }
39669 :
39670 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_r_state {
39671 : TALLOC_CTX *out_mem_ctx;
39672 : };
39673 :
39674 : static void dcerpc_clusapi_AddGroupToGroupSetDependency_r_done(struct tevent_req *subreq);
39675 :
39676 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSetDependency_r_send(TALLOC_CTX *mem_ctx,
39677 : struct tevent_context *ev,
39678 : struct dcerpc_binding_handle *h,
39679 : struct clusapi_AddGroupToGroupSetDependency *r)
39680 : {
39681 : struct tevent_req *req;
39682 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_r_state *state;
39683 : struct tevent_req *subreq;
39684 :
39685 0 : req = tevent_req_create(mem_ctx, &state,
39686 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_r_state);
39687 0 : if (req == NULL) {
39688 0 : return NULL;
39689 : }
39690 :
39691 0 : state->out_mem_ctx = talloc_new(state);
39692 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39693 0 : return tevent_req_post(req, ev);
39694 : }
39695 :
39696 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
39697 : NULL, &ndr_table_clusapi,
39698 0 : NDR_CLUSAPI_ADDGROUPTOGROUPSETDEPENDENCY, state->out_mem_ctx, r);
39699 0 : if (tevent_req_nomem(subreq, req)) {
39700 0 : return tevent_req_post(req, ev);
39701 : }
39702 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSetDependency_r_done, req);
39703 :
39704 0 : return req;
39705 : }
39706 :
39707 0 : static void dcerpc_clusapi_AddGroupToGroupSetDependency_r_done(struct tevent_req *subreq)
39708 : {
39709 0 : struct tevent_req *req =
39710 0 : tevent_req_callback_data(subreq,
39711 : struct tevent_req);
39712 : NTSTATUS status;
39713 :
39714 0 : status = dcerpc_binding_handle_call_recv(subreq);
39715 0 : TALLOC_FREE(subreq);
39716 0 : if (tevent_req_nterror(req, status)) {
39717 0 : return;
39718 : }
39719 :
39720 0 : tevent_req_done(req);
39721 : }
39722 :
39723 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
39724 : {
39725 0 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_r_state *state =
39726 0 : tevent_req_data(req,
39727 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_r_state);
39728 : NTSTATUS status;
39729 :
39730 0 : if (tevent_req_is_nterror(req, &status)) {
39731 0 : tevent_req_received(req);
39732 0 : return status;
39733 : }
39734 :
39735 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39736 :
39737 0 : tevent_req_received(req);
39738 0 : return NT_STATUS_OK;
39739 : }
39740 :
39741 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddGroupToGroupSetDependency *r)
39742 : {
39743 : NTSTATUS status;
39744 :
39745 0 : status = dcerpc_binding_handle_call(h,
39746 : NULL, &ndr_table_clusapi,
39747 : NDR_CLUSAPI_ADDGROUPTOGROUPSETDEPENDENCY, mem_ctx, r);
39748 :
39749 0 : return status;
39750 : }
39751 :
39752 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_state {
39753 : struct clusapi_AddGroupToGroupSetDependency orig;
39754 : struct clusapi_AddGroupToGroupSetDependency tmp;
39755 : TALLOC_CTX *out_mem_ctx;
39756 : };
39757 :
39758 : static void dcerpc_clusapi_AddGroupToGroupSetDependency_done(struct tevent_req *subreq);
39759 :
39760 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSetDependency_send(TALLOC_CTX *mem_ctx,
39761 : struct tevent_context *ev,
39762 : struct dcerpc_binding_handle *h,
39763 : struct policy_handle _DependentGroup /* [in] */,
39764 : struct policy_handle _ProviderGroupSet /* [in] */,
39765 : WERROR *_rpc_status /* [out] [ref] */)
39766 : {
39767 : struct tevent_req *req;
39768 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_state *state;
39769 : struct tevent_req *subreq;
39770 :
39771 0 : req = tevent_req_create(mem_ctx, &state,
39772 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_state);
39773 0 : if (req == NULL) {
39774 0 : return NULL;
39775 : }
39776 0 : state->out_mem_ctx = NULL;
39777 :
39778 : /* In parameters */
39779 0 : state->orig.in.DependentGroup = _DependentGroup;
39780 0 : state->orig.in.ProviderGroupSet = _ProviderGroupSet;
39781 :
39782 : /* Out parameters */
39783 0 : state->orig.out.rpc_status = _rpc_status;
39784 :
39785 : /* Result */
39786 0 : NDR_ZERO_STRUCT(state->orig.out.result);
39787 :
39788 0 : state->out_mem_ctx = talloc_named_const(state, 0,
39789 : "dcerpc_clusapi_AddGroupToGroupSetDependency_out_memory");
39790 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39791 0 : return tevent_req_post(req, ev);
39792 : }
39793 :
39794 : /* make a temporary copy, that we pass to the dispatch function */
39795 0 : state->tmp = state->orig;
39796 :
39797 0 : subreq = dcerpc_clusapi_AddGroupToGroupSetDependency_r_send(state, ev, h, &state->tmp);
39798 0 : if (tevent_req_nomem(subreq, req)) {
39799 0 : return tevent_req_post(req, ev);
39800 : }
39801 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSetDependency_done, req);
39802 0 : return req;
39803 : }
39804 :
39805 0 : static void dcerpc_clusapi_AddGroupToGroupSetDependency_done(struct tevent_req *subreq)
39806 : {
39807 0 : struct tevent_req *req = tevent_req_callback_data(
39808 : subreq, struct tevent_req);
39809 0 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_state *state = tevent_req_data(
39810 : req, struct dcerpc_clusapi_AddGroupToGroupSetDependency_state);
39811 : NTSTATUS status;
39812 : TALLOC_CTX *mem_ctx;
39813 :
39814 0 : if (state->out_mem_ctx) {
39815 0 : mem_ctx = state->out_mem_ctx;
39816 : } else {
39817 0 : mem_ctx = state;
39818 : }
39819 :
39820 0 : status = dcerpc_clusapi_AddGroupToGroupSetDependency_r_recv(subreq, mem_ctx);
39821 0 : TALLOC_FREE(subreq);
39822 0 : if (tevent_req_nterror(req, status)) {
39823 0 : return;
39824 : }
39825 :
39826 : /* Copy out parameters */
39827 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
39828 :
39829 : /* Copy result */
39830 0 : state->orig.out.result = state->tmp.out.result;
39831 :
39832 : /* Reset temporary structure */
39833 0 : NDR_ZERO_STRUCT(state->tmp);
39834 :
39835 0 : tevent_req_done(req);
39836 : }
39837 :
39838 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetDependency_recv(struct tevent_req *req,
39839 : TALLOC_CTX *mem_ctx,
39840 : WERROR *result)
39841 : {
39842 0 : struct dcerpc_clusapi_AddGroupToGroupSetDependency_state *state = tevent_req_data(
39843 : req, struct dcerpc_clusapi_AddGroupToGroupSetDependency_state);
39844 : NTSTATUS status;
39845 :
39846 0 : if (tevent_req_is_nterror(req, &status)) {
39847 0 : tevent_req_received(req);
39848 0 : return status;
39849 : }
39850 :
39851 : /* Steal possible out parameters to the callers context */
39852 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39853 :
39854 : /* Return result */
39855 0 : *result = state->orig.out.result;
39856 :
39857 0 : tevent_req_received(req);
39858 0 : return NT_STATUS_OK;
39859 : }
39860 :
39861 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetDependency(struct dcerpc_binding_handle *h,
39862 : TALLOC_CTX *mem_ctx,
39863 : struct policy_handle _DependentGroup /* [in] */,
39864 : struct policy_handle _ProviderGroupSet /* [in] */,
39865 : WERROR *_rpc_status /* [out] [ref] */,
39866 : WERROR *result)
39867 : {
39868 : struct clusapi_AddGroupToGroupSetDependency r;
39869 : NTSTATUS status;
39870 :
39871 : /* In parameters */
39872 0 : r.in.DependentGroup = _DependentGroup;
39873 0 : r.in.ProviderGroupSet = _ProviderGroupSet;
39874 :
39875 : /* Out parameters */
39876 0 : r.out.rpc_status = _rpc_status;
39877 :
39878 : /* Result */
39879 0 : NDR_ZERO_STRUCT(r.out.result);
39880 :
39881 0 : status = dcerpc_clusapi_AddGroupToGroupSetDependency_r(h, mem_ctx, &r);
39882 0 : if (!NT_STATUS_IS_OK(status)) {
39883 0 : return status;
39884 : }
39885 :
39886 : /* Return variables */
39887 0 : *_rpc_status = *r.out.rpc_status;
39888 :
39889 : /* Return result */
39890 0 : *result = r.out.result;
39891 :
39892 0 : return NT_STATUS_OK;
39893 : }
39894 :
39895 : struct dcerpc_clusapi_NodeGroupSetControl_r_state {
39896 : TALLOC_CTX *out_mem_ctx;
39897 : };
39898 :
39899 : static void dcerpc_clusapi_NodeGroupSetControl_r_done(struct tevent_req *subreq);
39900 :
39901 0 : struct tevent_req *dcerpc_clusapi_NodeGroupSetControl_r_send(TALLOC_CTX *mem_ctx,
39902 : struct tevent_context *ev,
39903 : struct dcerpc_binding_handle *h,
39904 : struct clusapi_NodeGroupSetControl *r)
39905 : {
39906 : struct tevent_req *req;
39907 : struct dcerpc_clusapi_NodeGroupSetControl_r_state *state;
39908 : struct tevent_req *subreq;
39909 :
39910 0 : req = tevent_req_create(mem_ctx, &state,
39911 : struct dcerpc_clusapi_NodeGroupSetControl_r_state);
39912 0 : if (req == NULL) {
39913 0 : return NULL;
39914 : }
39915 :
39916 0 : state->out_mem_ctx = talloc_new(state);
39917 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
39918 0 : return tevent_req_post(req, ev);
39919 : }
39920 :
39921 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
39922 : NULL, &ndr_table_clusapi,
39923 0 : NDR_CLUSAPI_NODEGROUPSETCONTROL, state->out_mem_ctx, r);
39924 0 : if (tevent_req_nomem(subreq, req)) {
39925 0 : return tevent_req_post(req, ev);
39926 : }
39927 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeGroupSetControl_r_done, req);
39928 :
39929 0 : return req;
39930 : }
39931 :
39932 0 : static void dcerpc_clusapi_NodeGroupSetControl_r_done(struct tevent_req *subreq)
39933 : {
39934 0 : struct tevent_req *req =
39935 0 : tevent_req_callback_data(subreq,
39936 : struct tevent_req);
39937 : NTSTATUS status;
39938 :
39939 0 : status = dcerpc_binding_handle_call_recv(subreq);
39940 0 : TALLOC_FREE(subreq);
39941 0 : if (tevent_req_nterror(req, status)) {
39942 0 : return;
39943 : }
39944 :
39945 0 : tevent_req_done(req);
39946 : }
39947 :
39948 0 : NTSTATUS dcerpc_clusapi_NodeGroupSetControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
39949 : {
39950 0 : struct dcerpc_clusapi_NodeGroupSetControl_r_state *state =
39951 0 : tevent_req_data(req,
39952 : struct dcerpc_clusapi_NodeGroupSetControl_r_state);
39953 : NTSTATUS status;
39954 :
39955 0 : if (tevent_req_is_nterror(req, &status)) {
39956 0 : tevent_req_received(req);
39957 0 : return status;
39958 : }
39959 :
39960 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
39961 :
39962 0 : tevent_req_received(req);
39963 0 : return NT_STATUS_OK;
39964 : }
39965 :
39966 0 : NTSTATUS dcerpc_clusapi_NodeGroupSetControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_NodeGroupSetControl *r)
39967 : {
39968 : NTSTATUS status;
39969 :
39970 0 : status = dcerpc_binding_handle_call(h,
39971 : NULL, &ndr_table_clusapi,
39972 : NDR_CLUSAPI_NODEGROUPSETCONTROL, mem_ctx, r);
39973 :
39974 0 : return status;
39975 : }
39976 :
39977 : struct dcerpc_clusapi_NodeGroupSetControl_state {
39978 : struct clusapi_NodeGroupSetControl orig;
39979 : struct clusapi_NodeGroupSetControl tmp;
39980 : TALLOC_CTX *out_mem_ctx;
39981 : };
39982 :
39983 : static void dcerpc_clusapi_NodeGroupSetControl_done(struct tevent_req *subreq);
39984 :
39985 0 : struct tevent_req *dcerpc_clusapi_NodeGroupSetControl_send(TALLOC_CTX *mem_ctx,
39986 : struct tevent_context *ev,
39987 : struct dcerpc_binding_handle *h,
39988 : struct policy_handle _hGroupSet /* [in] */,
39989 : struct policy_handle _hNode /* [in] */,
39990 : enum clusapi_GroupSetControlCode _dwControlCode /* [in] */,
39991 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
39992 : uint32_t _nInBufferSize /* [in] */,
39993 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
39994 : uint32_t _nOutBufferSize /* [in] [range(0,0x7FFFFFFF)] */,
39995 : uint32_t *_lpBytesReturned /* [out] [ref] */,
39996 : uint32_t *_lpcbRequired /* [out] [ref] */,
39997 : WERROR *_rpc_status /* [out] [ref] */)
39998 : {
39999 : struct tevent_req *req;
40000 : struct dcerpc_clusapi_NodeGroupSetControl_state *state;
40001 : struct tevent_req *subreq;
40002 :
40003 0 : req = tevent_req_create(mem_ctx, &state,
40004 : struct dcerpc_clusapi_NodeGroupSetControl_state);
40005 0 : if (req == NULL) {
40006 0 : return NULL;
40007 : }
40008 0 : state->out_mem_ctx = NULL;
40009 :
40010 : /* In parameters */
40011 0 : state->orig.in.hGroupSet = _hGroupSet;
40012 0 : state->orig.in.hNode = _hNode;
40013 0 : state->orig.in.dwControlCode = _dwControlCode;
40014 0 : state->orig.in.lpInBuffer = _lpInBuffer;
40015 0 : state->orig.in.nInBufferSize = _nInBufferSize;
40016 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
40017 :
40018 : /* Out parameters */
40019 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
40020 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
40021 0 : state->orig.out.lpcbRequired = _lpcbRequired;
40022 0 : state->orig.out.rpc_status = _rpc_status;
40023 :
40024 : /* Result */
40025 0 : NDR_ZERO_STRUCT(state->orig.out.result);
40026 :
40027 0 : state->out_mem_ctx = talloc_named_const(state, 0,
40028 : "dcerpc_clusapi_NodeGroupSetControl_out_memory");
40029 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40030 0 : return tevent_req_post(req, ev);
40031 : }
40032 :
40033 : /* make a temporary copy, that we pass to the dispatch function */
40034 0 : state->tmp = state->orig;
40035 :
40036 0 : subreq = dcerpc_clusapi_NodeGroupSetControl_r_send(state, ev, h, &state->tmp);
40037 0 : if (tevent_req_nomem(subreq, req)) {
40038 0 : return tevent_req_post(req, ev);
40039 : }
40040 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_NodeGroupSetControl_done, req);
40041 0 : return req;
40042 : }
40043 :
40044 0 : static void dcerpc_clusapi_NodeGroupSetControl_done(struct tevent_req *subreq)
40045 : {
40046 0 : struct tevent_req *req = tevent_req_callback_data(
40047 : subreq, struct tevent_req);
40048 0 : struct dcerpc_clusapi_NodeGroupSetControl_state *state = tevent_req_data(
40049 : req, struct dcerpc_clusapi_NodeGroupSetControl_state);
40050 : NTSTATUS status;
40051 : TALLOC_CTX *mem_ctx;
40052 :
40053 0 : if (state->out_mem_ctx) {
40054 0 : mem_ctx = state->out_mem_ctx;
40055 : } else {
40056 0 : mem_ctx = state;
40057 : }
40058 :
40059 0 : status = dcerpc_clusapi_NodeGroupSetControl_r_recv(subreq, mem_ctx);
40060 0 : TALLOC_FREE(subreq);
40061 0 : if (tevent_req_nterror(req, status)) {
40062 0 : return;
40063 : }
40064 :
40065 : /* Copy out parameters */
40066 : {
40067 : size_t _copy_len_lpOutBuffer;
40068 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
40069 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
40070 0 : return;
40071 : }
40072 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
40073 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
40074 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
40075 : }
40076 : }
40077 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
40078 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
40079 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
40080 :
40081 : /* Copy result */
40082 0 : state->orig.out.result = state->tmp.out.result;
40083 :
40084 : /* Reset temporary structure */
40085 0 : NDR_ZERO_STRUCT(state->tmp);
40086 :
40087 0 : tevent_req_done(req);
40088 : }
40089 :
40090 0 : NTSTATUS dcerpc_clusapi_NodeGroupSetControl_recv(struct tevent_req *req,
40091 : TALLOC_CTX *mem_ctx,
40092 : WERROR *result)
40093 : {
40094 0 : struct dcerpc_clusapi_NodeGroupSetControl_state *state = tevent_req_data(
40095 : req, struct dcerpc_clusapi_NodeGroupSetControl_state);
40096 : NTSTATUS status;
40097 :
40098 0 : if (tevent_req_is_nterror(req, &status)) {
40099 0 : tevent_req_received(req);
40100 0 : return status;
40101 : }
40102 :
40103 : /* Steal possible out parameters to the callers context */
40104 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40105 :
40106 : /* Return result */
40107 0 : *result = state->orig.out.result;
40108 :
40109 0 : tevent_req_received(req);
40110 0 : return NT_STATUS_OK;
40111 : }
40112 :
40113 0 : NTSTATUS dcerpc_clusapi_NodeGroupSetControl(struct dcerpc_binding_handle *h,
40114 : TALLOC_CTX *mem_ctx,
40115 : struct policy_handle _hGroupSet /* [in] */,
40116 : struct policy_handle _hNode /* [in] */,
40117 : enum clusapi_GroupSetControlCode _dwControlCode /* [in] */,
40118 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
40119 : uint32_t _nInBufferSize /* [in] */,
40120 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
40121 : uint32_t _nOutBufferSize /* [in] [range(0,0x7FFFFFFF)] */,
40122 : uint32_t *_lpBytesReturned /* [out] [ref] */,
40123 : uint32_t *_lpcbRequired /* [out] [ref] */,
40124 : WERROR *_rpc_status /* [out] [ref] */,
40125 : WERROR *result)
40126 : {
40127 : struct clusapi_NodeGroupSetControl r;
40128 : NTSTATUS status;
40129 :
40130 : /* In parameters */
40131 0 : r.in.hGroupSet = _hGroupSet;
40132 0 : r.in.hNode = _hNode;
40133 0 : r.in.dwControlCode = _dwControlCode;
40134 0 : r.in.lpInBuffer = _lpInBuffer;
40135 0 : r.in.nInBufferSize = _nInBufferSize;
40136 0 : r.in.nOutBufferSize = _nOutBufferSize;
40137 :
40138 : /* Out parameters */
40139 0 : r.out.lpOutBuffer = _lpOutBuffer;
40140 0 : r.out.lpBytesReturned = _lpBytesReturned;
40141 0 : r.out.lpcbRequired = _lpcbRequired;
40142 0 : r.out.rpc_status = _rpc_status;
40143 :
40144 : /* Result */
40145 0 : NDR_ZERO_STRUCT(r.out.result);
40146 :
40147 0 : status = dcerpc_clusapi_NodeGroupSetControl_r(h, mem_ctx, &r);
40148 0 : if (!NT_STATUS_IS_OK(status)) {
40149 0 : return status;
40150 : }
40151 :
40152 : /* Return variables */
40153 : {
40154 : size_t _copy_len_lpOutBuffer;
40155 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
40156 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
40157 : }
40158 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
40159 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
40160 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
40161 : }
40162 : }
40163 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
40164 0 : *_lpcbRequired = *r.out.lpcbRequired;
40165 0 : *_rpc_status = *r.out.rpc_status;
40166 :
40167 : /* Return result */
40168 0 : *result = r.out.result;
40169 :
40170 0 : return NT_STATUS_OK;
40171 : }
40172 :
40173 : struct dcerpc_clusapi_GroupSetControl_r_state {
40174 : TALLOC_CTX *out_mem_ctx;
40175 : };
40176 :
40177 : static void dcerpc_clusapi_GroupSetControl_r_done(struct tevent_req *subreq);
40178 :
40179 0 : struct tevent_req *dcerpc_clusapi_GroupSetControl_r_send(TALLOC_CTX *mem_ctx,
40180 : struct tevent_context *ev,
40181 : struct dcerpc_binding_handle *h,
40182 : struct clusapi_GroupSetControl *r)
40183 : {
40184 : struct tevent_req *req;
40185 : struct dcerpc_clusapi_GroupSetControl_r_state *state;
40186 : struct tevent_req *subreq;
40187 :
40188 0 : req = tevent_req_create(mem_ctx, &state,
40189 : struct dcerpc_clusapi_GroupSetControl_r_state);
40190 0 : if (req == NULL) {
40191 0 : return NULL;
40192 : }
40193 :
40194 0 : state->out_mem_ctx = talloc_new(state);
40195 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40196 0 : return tevent_req_post(req, ev);
40197 : }
40198 :
40199 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
40200 : NULL, &ndr_table_clusapi,
40201 0 : NDR_CLUSAPI_GROUPSETCONTROL, state->out_mem_ctx, r);
40202 0 : if (tevent_req_nomem(subreq, req)) {
40203 0 : return tevent_req_post(req, ev);
40204 : }
40205 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GroupSetControl_r_done, req);
40206 :
40207 0 : return req;
40208 : }
40209 :
40210 0 : static void dcerpc_clusapi_GroupSetControl_r_done(struct tevent_req *subreq)
40211 : {
40212 0 : struct tevent_req *req =
40213 0 : tevent_req_callback_data(subreq,
40214 : struct tevent_req);
40215 : NTSTATUS status;
40216 :
40217 0 : status = dcerpc_binding_handle_call_recv(subreq);
40218 0 : TALLOC_FREE(subreq);
40219 0 : if (tevent_req_nterror(req, status)) {
40220 0 : return;
40221 : }
40222 :
40223 0 : tevent_req_done(req);
40224 : }
40225 :
40226 0 : NTSTATUS dcerpc_clusapi_GroupSetControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
40227 : {
40228 0 : struct dcerpc_clusapi_GroupSetControl_r_state *state =
40229 0 : tevent_req_data(req,
40230 : struct dcerpc_clusapi_GroupSetControl_r_state);
40231 : NTSTATUS status;
40232 :
40233 0 : if (tevent_req_is_nterror(req, &status)) {
40234 0 : tevent_req_received(req);
40235 0 : return status;
40236 : }
40237 :
40238 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40239 :
40240 0 : tevent_req_received(req);
40241 0 : return NT_STATUS_OK;
40242 : }
40243 :
40244 0 : NTSTATUS dcerpc_clusapi_GroupSetControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_GroupSetControl *r)
40245 : {
40246 : NTSTATUS status;
40247 :
40248 0 : status = dcerpc_binding_handle_call(h,
40249 : NULL, &ndr_table_clusapi,
40250 : NDR_CLUSAPI_GROUPSETCONTROL, mem_ctx, r);
40251 :
40252 0 : return status;
40253 : }
40254 :
40255 : struct dcerpc_clusapi_GroupSetControl_state {
40256 : struct clusapi_GroupSetControl orig;
40257 : struct clusapi_GroupSetControl tmp;
40258 : TALLOC_CTX *out_mem_ctx;
40259 : };
40260 :
40261 : static void dcerpc_clusapi_GroupSetControl_done(struct tevent_req *subreq);
40262 :
40263 0 : struct tevent_req *dcerpc_clusapi_GroupSetControl_send(TALLOC_CTX *mem_ctx,
40264 : struct tevent_context *ev,
40265 : struct dcerpc_binding_handle *h,
40266 : struct policy_handle _hGroupSet /* [in] */,
40267 : enum clusapi_GroupSetControlCode _dwControlCode /* [in] */,
40268 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
40269 : uint32_t _nInBufferSize /* [in] */,
40270 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
40271 : uint32_t _nOutBufferSize /* [in] [range(0,0x7FFFFFFF)] */,
40272 : uint32_t *_lpBytesReturned /* [out] [ref] */,
40273 : uint32_t *_lpcbRequired /* [out] [ref] */,
40274 : WERROR *_rpc_status /* [out] [ref] */)
40275 : {
40276 : struct tevent_req *req;
40277 : struct dcerpc_clusapi_GroupSetControl_state *state;
40278 : struct tevent_req *subreq;
40279 :
40280 0 : req = tevent_req_create(mem_ctx, &state,
40281 : struct dcerpc_clusapi_GroupSetControl_state);
40282 0 : if (req == NULL) {
40283 0 : return NULL;
40284 : }
40285 0 : state->out_mem_ctx = NULL;
40286 :
40287 : /* In parameters */
40288 0 : state->orig.in.hGroupSet = _hGroupSet;
40289 0 : state->orig.in.dwControlCode = _dwControlCode;
40290 0 : state->orig.in.lpInBuffer = _lpInBuffer;
40291 0 : state->orig.in.nInBufferSize = _nInBufferSize;
40292 0 : state->orig.in.nOutBufferSize = _nOutBufferSize;
40293 :
40294 : /* Out parameters */
40295 0 : state->orig.out.lpOutBuffer = _lpOutBuffer;
40296 0 : state->orig.out.lpBytesReturned = _lpBytesReturned;
40297 0 : state->orig.out.lpcbRequired = _lpcbRequired;
40298 0 : state->orig.out.rpc_status = _rpc_status;
40299 :
40300 : /* Result */
40301 0 : NDR_ZERO_STRUCT(state->orig.out.result);
40302 :
40303 0 : state->out_mem_ctx = talloc_named_const(state, 0,
40304 : "dcerpc_clusapi_GroupSetControl_out_memory");
40305 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40306 0 : return tevent_req_post(req, ev);
40307 : }
40308 :
40309 : /* make a temporary copy, that we pass to the dispatch function */
40310 0 : state->tmp = state->orig;
40311 :
40312 0 : subreq = dcerpc_clusapi_GroupSetControl_r_send(state, ev, h, &state->tmp);
40313 0 : if (tevent_req_nomem(subreq, req)) {
40314 0 : return tevent_req_post(req, ev);
40315 : }
40316 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_GroupSetControl_done, req);
40317 0 : return req;
40318 : }
40319 :
40320 0 : static void dcerpc_clusapi_GroupSetControl_done(struct tevent_req *subreq)
40321 : {
40322 0 : struct tevent_req *req = tevent_req_callback_data(
40323 : subreq, struct tevent_req);
40324 0 : struct dcerpc_clusapi_GroupSetControl_state *state = tevent_req_data(
40325 : req, struct dcerpc_clusapi_GroupSetControl_state);
40326 : NTSTATUS status;
40327 : TALLOC_CTX *mem_ctx;
40328 :
40329 0 : if (state->out_mem_ctx) {
40330 0 : mem_ctx = state->out_mem_ctx;
40331 : } else {
40332 0 : mem_ctx = state;
40333 : }
40334 :
40335 0 : status = dcerpc_clusapi_GroupSetControl_r_recv(subreq, mem_ctx);
40336 0 : TALLOC_FREE(subreq);
40337 0 : if (tevent_req_nterror(req, status)) {
40338 0 : return;
40339 : }
40340 :
40341 : /* Copy out parameters */
40342 : {
40343 : size_t _copy_len_lpOutBuffer;
40344 0 : if ((*state->tmp.out.lpBytesReturned) > (state->tmp.in.nOutBufferSize)) {
40345 0 : tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
40346 0 : return;
40347 : }
40348 0 : _copy_len_lpOutBuffer = *state->tmp.out.lpBytesReturned;
40349 0 : if (state->orig.out.lpOutBuffer != state->tmp.out.lpOutBuffer) {
40350 0 : memcpy(state->orig.out.lpOutBuffer, state->tmp.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*state->orig.out.lpOutBuffer));
40351 : }
40352 : }
40353 0 : *state->orig.out.lpBytesReturned = *state->tmp.out.lpBytesReturned;
40354 0 : *state->orig.out.lpcbRequired = *state->tmp.out.lpcbRequired;
40355 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
40356 :
40357 : /* Copy result */
40358 0 : state->orig.out.result = state->tmp.out.result;
40359 :
40360 : /* Reset temporary structure */
40361 0 : NDR_ZERO_STRUCT(state->tmp);
40362 :
40363 0 : tevent_req_done(req);
40364 : }
40365 :
40366 0 : NTSTATUS dcerpc_clusapi_GroupSetControl_recv(struct tevent_req *req,
40367 : TALLOC_CTX *mem_ctx,
40368 : WERROR *result)
40369 : {
40370 0 : struct dcerpc_clusapi_GroupSetControl_state *state = tevent_req_data(
40371 : req, struct dcerpc_clusapi_GroupSetControl_state);
40372 : NTSTATUS status;
40373 :
40374 0 : if (tevent_req_is_nterror(req, &status)) {
40375 0 : tevent_req_received(req);
40376 0 : return status;
40377 : }
40378 :
40379 : /* Steal possible out parameters to the callers context */
40380 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40381 :
40382 : /* Return result */
40383 0 : *result = state->orig.out.result;
40384 :
40385 0 : tevent_req_received(req);
40386 0 : return NT_STATUS_OK;
40387 : }
40388 :
40389 0 : NTSTATUS dcerpc_clusapi_GroupSetControl(struct dcerpc_binding_handle *h,
40390 : TALLOC_CTX *mem_ctx,
40391 : struct policy_handle _hGroupSet /* [in] */,
40392 : enum clusapi_GroupSetControlCode _dwControlCode /* [in] */,
40393 : uint8_t *_lpInBuffer /* [in] [size_is(nInBufferSize),unique] */,
40394 : uint32_t _nInBufferSize /* [in] */,
40395 : uint8_t *_lpOutBuffer /* [out] [length_is(*lpBytesReturned),ref,size_is(nOutBufferSize)] */,
40396 : uint32_t _nOutBufferSize /* [in] [range(0,0x7FFFFFFF)] */,
40397 : uint32_t *_lpBytesReturned /* [out] [ref] */,
40398 : uint32_t *_lpcbRequired /* [out] [ref] */,
40399 : WERROR *_rpc_status /* [out] [ref] */,
40400 : WERROR *result)
40401 : {
40402 : struct clusapi_GroupSetControl r;
40403 : NTSTATUS status;
40404 :
40405 : /* In parameters */
40406 0 : r.in.hGroupSet = _hGroupSet;
40407 0 : r.in.dwControlCode = _dwControlCode;
40408 0 : r.in.lpInBuffer = _lpInBuffer;
40409 0 : r.in.nInBufferSize = _nInBufferSize;
40410 0 : r.in.nOutBufferSize = _nOutBufferSize;
40411 :
40412 : /* Out parameters */
40413 0 : r.out.lpOutBuffer = _lpOutBuffer;
40414 0 : r.out.lpBytesReturned = _lpBytesReturned;
40415 0 : r.out.lpcbRequired = _lpcbRequired;
40416 0 : r.out.rpc_status = _rpc_status;
40417 :
40418 : /* Result */
40419 0 : NDR_ZERO_STRUCT(r.out.result);
40420 :
40421 0 : status = dcerpc_clusapi_GroupSetControl_r(h, mem_ctx, &r);
40422 0 : if (!NT_STATUS_IS_OK(status)) {
40423 0 : return status;
40424 : }
40425 :
40426 : /* Return variables */
40427 : {
40428 : size_t _copy_len_lpOutBuffer;
40429 0 : if ((*r.out.lpBytesReturned) > (r.in.nOutBufferSize)) {
40430 0 : return NT_STATUS_INVALID_NETWORK_RESPONSE;
40431 : }
40432 0 : _copy_len_lpOutBuffer = *r.out.lpBytesReturned;
40433 0 : if (_lpOutBuffer != r.out.lpOutBuffer) {
40434 0 : memcpy(_lpOutBuffer, r.out.lpOutBuffer, _copy_len_lpOutBuffer * sizeof(*_lpOutBuffer));
40435 : }
40436 : }
40437 0 : *_lpBytesReturned = *r.out.lpBytesReturned;
40438 0 : *_lpcbRequired = *r.out.lpcbRequired;
40439 0 : *_rpc_status = *r.out.rpc_status;
40440 :
40441 : /* Return result */
40442 0 : *result = r.out.result;
40443 :
40444 0 : return NT_STATUS_OK;
40445 : }
40446 :
40447 : struct dcerpc_clusapi_SetGroupDependencyExpression_r_state {
40448 : TALLOC_CTX *out_mem_ctx;
40449 : };
40450 :
40451 : static void dcerpc_clusapi_SetGroupDependencyExpression_r_done(struct tevent_req *subreq);
40452 :
40453 0 : struct tevent_req *dcerpc_clusapi_SetGroupDependencyExpression_r_send(TALLOC_CTX *mem_ctx,
40454 : struct tevent_context *ev,
40455 : struct dcerpc_binding_handle *h,
40456 : struct clusapi_SetGroupDependencyExpression *r)
40457 : {
40458 : struct tevent_req *req;
40459 : struct dcerpc_clusapi_SetGroupDependencyExpression_r_state *state;
40460 : struct tevent_req *subreq;
40461 :
40462 0 : req = tevent_req_create(mem_ctx, &state,
40463 : struct dcerpc_clusapi_SetGroupDependencyExpression_r_state);
40464 0 : if (req == NULL) {
40465 0 : return NULL;
40466 : }
40467 :
40468 0 : state->out_mem_ctx = talloc_new(state);
40469 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40470 0 : return tevent_req_post(req, ev);
40471 : }
40472 :
40473 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
40474 : NULL, &ndr_table_clusapi,
40475 0 : NDR_CLUSAPI_SETGROUPDEPENDENCYEXPRESSION, state->out_mem_ctx, r);
40476 0 : if (tevent_req_nomem(subreq, req)) {
40477 0 : return tevent_req_post(req, ev);
40478 : }
40479 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupDependencyExpression_r_done, req);
40480 :
40481 0 : return req;
40482 : }
40483 :
40484 0 : static void dcerpc_clusapi_SetGroupDependencyExpression_r_done(struct tevent_req *subreq)
40485 : {
40486 0 : struct tevent_req *req =
40487 0 : tevent_req_callback_data(subreq,
40488 : struct tevent_req);
40489 : NTSTATUS status;
40490 :
40491 0 : status = dcerpc_binding_handle_call_recv(subreq);
40492 0 : TALLOC_FREE(subreq);
40493 0 : if (tevent_req_nterror(req, status)) {
40494 0 : return;
40495 : }
40496 :
40497 0 : tevent_req_done(req);
40498 : }
40499 :
40500 0 : NTSTATUS dcerpc_clusapi_SetGroupDependencyExpression_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
40501 : {
40502 0 : struct dcerpc_clusapi_SetGroupDependencyExpression_r_state *state =
40503 0 : tevent_req_data(req,
40504 : struct dcerpc_clusapi_SetGroupDependencyExpression_r_state);
40505 : NTSTATUS status;
40506 :
40507 0 : if (tevent_req_is_nterror(req, &status)) {
40508 0 : tevent_req_received(req);
40509 0 : return status;
40510 : }
40511 :
40512 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40513 :
40514 0 : tevent_req_received(req);
40515 0 : return NT_STATUS_OK;
40516 : }
40517 :
40518 0 : NTSTATUS dcerpc_clusapi_SetGroupDependencyExpression_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetGroupDependencyExpression *r)
40519 : {
40520 : NTSTATUS status;
40521 :
40522 0 : status = dcerpc_binding_handle_call(h,
40523 : NULL, &ndr_table_clusapi,
40524 : NDR_CLUSAPI_SETGROUPDEPENDENCYEXPRESSION, mem_ctx, r);
40525 :
40526 0 : return status;
40527 : }
40528 :
40529 : struct dcerpc_clusapi_SetGroupDependencyExpression_state {
40530 : struct clusapi_SetGroupDependencyExpression orig;
40531 : struct clusapi_SetGroupDependencyExpression tmp;
40532 : TALLOC_CTX *out_mem_ctx;
40533 : };
40534 :
40535 : static void dcerpc_clusapi_SetGroupDependencyExpression_done(struct tevent_req *subreq);
40536 :
40537 0 : struct tevent_req *dcerpc_clusapi_SetGroupDependencyExpression_send(TALLOC_CTX *mem_ctx,
40538 : struct tevent_context *ev,
40539 : struct dcerpc_binding_handle *h,
40540 : struct policy_handle _hGroup /* [in] */,
40541 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),ref] */,
40542 : WERROR *_rpc_status /* [out] [ref] */)
40543 : {
40544 : struct tevent_req *req;
40545 : struct dcerpc_clusapi_SetGroupDependencyExpression_state *state;
40546 : struct tevent_req *subreq;
40547 :
40548 0 : req = tevent_req_create(mem_ctx, &state,
40549 : struct dcerpc_clusapi_SetGroupDependencyExpression_state);
40550 0 : if (req == NULL) {
40551 0 : return NULL;
40552 : }
40553 0 : state->out_mem_ctx = NULL;
40554 :
40555 : /* In parameters */
40556 0 : state->orig.in.hGroup = _hGroup;
40557 0 : state->orig.in.lpszDependencyExpression = _lpszDependencyExpression;
40558 :
40559 : /* Out parameters */
40560 0 : state->orig.out.rpc_status = _rpc_status;
40561 :
40562 : /* Result */
40563 0 : NDR_ZERO_STRUCT(state->orig.out.result);
40564 :
40565 0 : state->out_mem_ctx = talloc_named_const(state, 0,
40566 : "dcerpc_clusapi_SetGroupDependencyExpression_out_memory");
40567 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40568 0 : return tevent_req_post(req, ev);
40569 : }
40570 :
40571 : /* make a temporary copy, that we pass to the dispatch function */
40572 0 : state->tmp = state->orig;
40573 :
40574 0 : subreq = dcerpc_clusapi_SetGroupDependencyExpression_r_send(state, ev, h, &state->tmp);
40575 0 : if (tevent_req_nomem(subreq, req)) {
40576 0 : return tevent_req_post(req, ev);
40577 : }
40578 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupDependencyExpression_done, req);
40579 0 : return req;
40580 : }
40581 :
40582 0 : static void dcerpc_clusapi_SetGroupDependencyExpression_done(struct tevent_req *subreq)
40583 : {
40584 0 : struct tevent_req *req = tevent_req_callback_data(
40585 : subreq, struct tevent_req);
40586 0 : struct dcerpc_clusapi_SetGroupDependencyExpression_state *state = tevent_req_data(
40587 : req, struct dcerpc_clusapi_SetGroupDependencyExpression_state);
40588 : NTSTATUS status;
40589 : TALLOC_CTX *mem_ctx;
40590 :
40591 0 : if (state->out_mem_ctx) {
40592 0 : mem_ctx = state->out_mem_ctx;
40593 : } else {
40594 0 : mem_ctx = state;
40595 : }
40596 :
40597 0 : status = dcerpc_clusapi_SetGroupDependencyExpression_r_recv(subreq, mem_ctx);
40598 0 : TALLOC_FREE(subreq);
40599 0 : if (tevent_req_nterror(req, status)) {
40600 0 : return;
40601 : }
40602 :
40603 : /* Copy out parameters */
40604 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
40605 :
40606 : /* Copy result */
40607 0 : state->orig.out.result = state->tmp.out.result;
40608 :
40609 : /* Reset temporary structure */
40610 0 : NDR_ZERO_STRUCT(state->tmp);
40611 :
40612 0 : tevent_req_done(req);
40613 : }
40614 :
40615 0 : NTSTATUS dcerpc_clusapi_SetGroupDependencyExpression_recv(struct tevent_req *req,
40616 : TALLOC_CTX *mem_ctx,
40617 : WERROR *result)
40618 : {
40619 0 : struct dcerpc_clusapi_SetGroupDependencyExpression_state *state = tevent_req_data(
40620 : req, struct dcerpc_clusapi_SetGroupDependencyExpression_state);
40621 : NTSTATUS status;
40622 :
40623 0 : if (tevent_req_is_nterror(req, &status)) {
40624 0 : tevent_req_received(req);
40625 0 : return status;
40626 : }
40627 :
40628 : /* Steal possible out parameters to the callers context */
40629 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40630 :
40631 : /* Return result */
40632 0 : *result = state->orig.out.result;
40633 :
40634 0 : tevent_req_received(req);
40635 0 : return NT_STATUS_OK;
40636 : }
40637 :
40638 0 : NTSTATUS dcerpc_clusapi_SetGroupDependencyExpression(struct dcerpc_binding_handle *h,
40639 : TALLOC_CTX *mem_ctx,
40640 : struct policy_handle _hGroup /* [in] */,
40641 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),ref] */,
40642 : WERROR *_rpc_status /* [out] [ref] */,
40643 : WERROR *result)
40644 : {
40645 : struct clusapi_SetGroupDependencyExpression r;
40646 : NTSTATUS status;
40647 :
40648 : /* In parameters */
40649 0 : r.in.hGroup = _hGroup;
40650 0 : r.in.lpszDependencyExpression = _lpszDependencyExpression;
40651 :
40652 : /* Out parameters */
40653 0 : r.out.rpc_status = _rpc_status;
40654 :
40655 : /* Result */
40656 0 : NDR_ZERO_STRUCT(r.out.result);
40657 :
40658 0 : status = dcerpc_clusapi_SetGroupDependencyExpression_r(h, mem_ctx, &r);
40659 0 : if (!NT_STATUS_IS_OK(status)) {
40660 0 : return status;
40661 : }
40662 :
40663 : /* Return variables */
40664 0 : *_rpc_status = *r.out.rpc_status;
40665 :
40666 : /* Return result */
40667 0 : *result = r.out.result;
40668 :
40669 0 : return NT_STATUS_OK;
40670 : }
40671 :
40672 : struct dcerpc_clusapi_RemoveClusterGroupDependency_r_state {
40673 : TALLOC_CTX *out_mem_ctx;
40674 : };
40675 :
40676 : static void dcerpc_clusapi_RemoveClusterGroupDependency_r_done(struct tevent_req *subreq);
40677 :
40678 0 : struct tevent_req *dcerpc_clusapi_RemoveClusterGroupDependency_r_send(TALLOC_CTX *mem_ctx,
40679 : struct tevent_context *ev,
40680 : struct dcerpc_binding_handle *h,
40681 : struct clusapi_RemoveClusterGroupDependency *r)
40682 : {
40683 : struct tevent_req *req;
40684 : struct dcerpc_clusapi_RemoveClusterGroupDependency_r_state *state;
40685 : struct tevent_req *subreq;
40686 :
40687 0 : req = tevent_req_create(mem_ctx, &state,
40688 : struct dcerpc_clusapi_RemoveClusterGroupDependency_r_state);
40689 0 : if (req == NULL) {
40690 0 : return NULL;
40691 : }
40692 :
40693 0 : state->out_mem_ctx = talloc_new(state);
40694 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40695 0 : return tevent_req_post(req, ev);
40696 : }
40697 :
40698 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
40699 : NULL, &ndr_table_clusapi,
40700 0 : NDR_CLUSAPI_REMOVECLUSTERGROUPDEPENDENCY, state->out_mem_ctx, r);
40701 0 : if (tevent_req_nomem(subreq, req)) {
40702 0 : return tevent_req_post(req, ev);
40703 : }
40704 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveClusterGroupDependency_r_done, req);
40705 :
40706 0 : return req;
40707 : }
40708 :
40709 0 : static void dcerpc_clusapi_RemoveClusterGroupDependency_r_done(struct tevent_req *subreq)
40710 : {
40711 0 : struct tevent_req *req =
40712 0 : tevent_req_callback_data(subreq,
40713 : struct tevent_req);
40714 : NTSTATUS status;
40715 :
40716 0 : status = dcerpc_binding_handle_call_recv(subreq);
40717 0 : TALLOC_FREE(subreq);
40718 0 : if (tevent_req_nterror(req, status)) {
40719 0 : return;
40720 : }
40721 :
40722 0 : tevent_req_done(req);
40723 : }
40724 :
40725 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
40726 : {
40727 0 : struct dcerpc_clusapi_RemoveClusterGroupDependency_r_state *state =
40728 0 : tevent_req_data(req,
40729 : struct dcerpc_clusapi_RemoveClusterGroupDependency_r_state);
40730 : NTSTATUS status;
40731 :
40732 0 : if (tevent_req_is_nterror(req, &status)) {
40733 0 : tevent_req_received(req);
40734 0 : return status;
40735 : }
40736 :
40737 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40738 :
40739 0 : tevent_req_received(req);
40740 0 : return NT_STATUS_OK;
40741 : }
40742 :
40743 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveClusterGroupDependency *r)
40744 : {
40745 : NTSTATUS status;
40746 :
40747 0 : status = dcerpc_binding_handle_call(h,
40748 : NULL, &ndr_table_clusapi,
40749 : NDR_CLUSAPI_REMOVECLUSTERGROUPDEPENDENCY, mem_ctx, r);
40750 :
40751 0 : return status;
40752 : }
40753 :
40754 : struct dcerpc_clusapi_RemoveClusterGroupDependency_state {
40755 : struct clusapi_RemoveClusterGroupDependency orig;
40756 : struct clusapi_RemoveClusterGroupDependency tmp;
40757 : TALLOC_CTX *out_mem_ctx;
40758 : };
40759 :
40760 : static void dcerpc_clusapi_RemoveClusterGroupDependency_done(struct tevent_req *subreq);
40761 :
40762 0 : struct tevent_req *dcerpc_clusapi_RemoveClusterGroupDependency_send(TALLOC_CTX *mem_ctx,
40763 : struct tevent_context *ev,
40764 : struct dcerpc_binding_handle *h,
40765 : struct policy_handle _hGroup /* [in] */,
40766 : struct policy_handle _hDependsOn /* [in] */,
40767 : WERROR *_rpc_status /* [out] [ref] */)
40768 : {
40769 : struct tevent_req *req;
40770 : struct dcerpc_clusapi_RemoveClusterGroupDependency_state *state;
40771 : struct tevent_req *subreq;
40772 :
40773 0 : req = tevent_req_create(mem_ctx, &state,
40774 : struct dcerpc_clusapi_RemoveClusterGroupDependency_state);
40775 0 : if (req == NULL) {
40776 0 : return NULL;
40777 : }
40778 0 : state->out_mem_ctx = NULL;
40779 :
40780 : /* In parameters */
40781 0 : state->orig.in.hGroup = _hGroup;
40782 0 : state->orig.in.hDependsOn = _hDependsOn;
40783 :
40784 : /* Out parameters */
40785 0 : state->orig.out.rpc_status = _rpc_status;
40786 :
40787 : /* Result */
40788 0 : NDR_ZERO_STRUCT(state->orig.out.result);
40789 :
40790 0 : state->out_mem_ctx = talloc_named_const(state, 0,
40791 : "dcerpc_clusapi_RemoveClusterGroupDependency_out_memory");
40792 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40793 0 : return tevent_req_post(req, ev);
40794 : }
40795 :
40796 : /* make a temporary copy, that we pass to the dispatch function */
40797 0 : state->tmp = state->orig;
40798 :
40799 0 : subreq = dcerpc_clusapi_RemoveClusterGroupDependency_r_send(state, ev, h, &state->tmp);
40800 0 : if (tevent_req_nomem(subreq, req)) {
40801 0 : return tevent_req_post(req, ev);
40802 : }
40803 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveClusterGroupDependency_done, req);
40804 0 : return req;
40805 : }
40806 :
40807 0 : static void dcerpc_clusapi_RemoveClusterGroupDependency_done(struct tevent_req *subreq)
40808 : {
40809 0 : struct tevent_req *req = tevent_req_callback_data(
40810 : subreq, struct tevent_req);
40811 0 : struct dcerpc_clusapi_RemoveClusterGroupDependency_state *state = tevent_req_data(
40812 : req, struct dcerpc_clusapi_RemoveClusterGroupDependency_state);
40813 : NTSTATUS status;
40814 : TALLOC_CTX *mem_ctx;
40815 :
40816 0 : if (state->out_mem_ctx) {
40817 0 : mem_ctx = state->out_mem_ctx;
40818 : } else {
40819 0 : mem_ctx = state;
40820 : }
40821 :
40822 0 : status = dcerpc_clusapi_RemoveClusterGroupDependency_r_recv(subreq, mem_ctx);
40823 0 : TALLOC_FREE(subreq);
40824 0 : if (tevent_req_nterror(req, status)) {
40825 0 : return;
40826 : }
40827 :
40828 : /* Copy out parameters */
40829 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
40830 :
40831 : /* Copy result */
40832 0 : state->orig.out.result = state->tmp.out.result;
40833 :
40834 : /* Reset temporary structure */
40835 0 : NDR_ZERO_STRUCT(state->tmp);
40836 :
40837 0 : tevent_req_done(req);
40838 : }
40839 :
40840 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupDependency_recv(struct tevent_req *req,
40841 : TALLOC_CTX *mem_ctx,
40842 : WERROR *result)
40843 : {
40844 0 : struct dcerpc_clusapi_RemoveClusterGroupDependency_state *state = tevent_req_data(
40845 : req, struct dcerpc_clusapi_RemoveClusterGroupDependency_state);
40846 : NTSTATUS status;
40847 :
40848 0 : if (tevent_req_is_nterror(req, &status)) {
40849 0 : tevent_req_received(req);
40850 0 : return status;
40851 : }
40852 :
40853 : /* Steal possible out parameters to the callers context */
40854 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40855 :
40856 : /* Return result */
40857 0 : *result = state->orig.out.result;
40858 :
40859 0 : tevent_req_received(req);
40860 0 : return NT_STATUS_OK;
40861 : }
40862 :
40863 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupDependency(struct dcerpc_binding_handle *h,
40864 : TALLOC_CTX *mem_ctx,
40865 : struct policy_handle _hGroup /* [in] */,
40866 : struct policy_handle _hDependsOn /* [in] */,
40867 : WERROR *_rpc_status /* [out] [ref] */,
40868 : WERROR *result)
40869 : {
40870 : struct clusapi_RemoveClusterGroupDependency r;
40871 : NTSTATUS status;
40872 :
40873 : /* In parameters */
40874 0 : r.in.hGroup = _hGroup;
40875 0 : r.in.hDependsOn = _hDependsOn;
40876 :
40877 : /* Out parameters */
40878 0 : r.out.rpc_status = _rpc_status;
40879 :
40880 : /* Result */
40881 0 : NDR_ZERO_STRUCT(r.out.result);
40882 :
40883 0 : status = dcerpc_clusapi_RemoveClusterGroupDependency_r(h, mem_ctx, &r);
40884 0 : if (!NT_STATUS_IS_OK(status)) {
40885 0 : return status;
40886 : }
40887 :
40888 : /* Return variables */
40889 0 : *_rpc_status = *r.out.rpc_status;
40890 :
40891 : /* Return result */
40892 0 : *result = r.out.result;
40893 :
40894 0 : return NT_STATUS_OK;
40895 : }
40896 :
40897 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_r_state {
40898 : TALLOC_CTX *out_mem_ctx;
40899 : };
40900 :
40901 : static void dcerpc_clusapi_SetGroupSetDependencyExpression_r_done(struct tevent_req *subreq);
40902 :
40903 0 : struct tevent_req *dcerpc_clusapi_SetGroupSetDependencyExpression_r_send(TALLOC_CTX *mem_ctx,
40904 : struct tevent_context *ev,
40905 : struct dcerpc_binding_handle *h,
40906 : struct clusapi_SetGroupSetDependencyExpression *r)
40907 : {
40908 : struct tevent_req *req;
40909 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_r_state *state;
40910 : struct tevent_req *subreq;
40911 :
40912 0 : req = tevent_req_create(mem_ctx, &state,
40913 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_r_state);
40914 0 : if (req == NULL) {
40915 0 : return NULL;
40916 : }
40917 :
40918 0 : state->out_mem_ctx = talloc_new(state);
40919 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
40920 0 : return tevent_req_post(req, ev);
40921 : }
40922 :
40923 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
40924 : NULL, &ndr_table_clusapi,
40925 0 : NDR_CLUSAPI_SETGROUPSETDEPENDENCYEXPRESSION, state->out_mem_ctx, r);
40926 0 : if (tevent_req_nomem(subreq, req)) {
40927 0 : return tevent_req_post(req, ev);
40928 : }
40929 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupSetDependencyExpression_r_done, req);
40930 :
40931 0 : return req;
40932 : }
40933 :
40934 0 : static void dcerpc_clusapi_SetGroupSetDependencyExpression_r_done(struct tevent_req *subreq)
40935 : {
40936 0 : struct tevent_req *req =
40937 0 : tevent_req_callback_data(subreq,
40938 : struct tevent_req);
40939 : NTSTATUS status;
40940 :
40941 0 : status = dcerpc_binding_handle_call_recv(subreq);
40942 0 : TALLOC_FREE(subreq);
40943 0 : if (tevent_req_nterror(req, status)) {
40944 0 : return;
40945 : }
40946 :
40947 0 : tevent_req_done(req);
40948 : }
40949 :
40950 0 : NTSTATUS dcerpc_clusapi_SetGroupSetDependencyExpression_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
40951 : {
40952 0 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_r_state *state =
40953 0 : tevent_req_data(req,
40954 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_r_state);
40955 : NTSTATUS status;
40956 :
40957 0 : if (tevent_req_is_nterror(req, &status)) {
40958 0 : tevent_req_received(req);
40959 0 : return status;
40960 : }
40961 :
40962 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
40963 :
40964 0 : tevent_req_received(req);
40965 0 : return NT_STATUS_OK;
40966 : }
40967 :
40968 0 : NTSTATUS dcerpc_clusapi_SetGroupSetDependencyExpression_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_SetGroupSetDependencyExpression *r)
40969 : {
40970 : NTSTATUS status;
40971 :
40972 0 : status = dcerpc_binding_handle_call(h,
40973 : NULL, &ndr_table_clusapi,
40974 : NDR_CLUSAPI_SETGROUPSETDEPENDENCYEXPRESSION, mem_ctx, r);
40975 :
40976 0 : return status;
40977 : }
40978 :
40979 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_state {
40980 : struct clusapi_SetGroupSetDependencyExpression orig;
40981 : struct clusapi_SetGroupSetDependencyExpression tmp;
40982 : TALLOC_CTX *out_mem_ctx;
40983 : };
40984 :
40985 : static void dcerpc_clusapi_SetGroupSetDependencyExpression_done(struct tevent_req *subreq);
40986 :
40987 0 : struct tevent_req *dcerpc_clusapi_SetGroupSetDependencyExpression_send(TALLOC_CTX *mem_ctx,
40988 : struct tevent_context *ev,
40989 : struct dcerpc_binding_handle *h,
40990 : struct policy_handle _hGroupSet /* [in] */,
40991 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),ref] */,
40992 : WERROR *_rpc_status /* [out] [ref] */)
40993 : {
40994 : struct tevent_req *req;
40995 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_state *state;
40996 : struct tevent_req *subreq;
40997 :
40998 0 : req = tevent_req_create(mem_ctx, &state,
40999 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_state);
41000 0 : if (req == NULL) {
41001 0 : return NULL;
41002 : }
41003 0 : state->out_mem_ctx = NULL;
41004 :
41005 : /* In parameters */
41006 0 : state->orig.in.hGroupSet = _hGroupSet;
41007 0 : state->orig.in.lpszDependencyExpression = _lpszDependencyExpression;
41008 :
41009 : /* Out parameters */
41010 0 : state->orig.out.rpc_status = _rpc_status;
41011 :
41012 : /* Result */
41013 0 : NDR_ZERO_STRUCT(state->orig.out.result);
41014 :
41015 0 : state->out_mem_ctx = talloc_named_const(state, 0,
41016 : "dcerpc_clusapi_SetGroupSetDependencyExpression_out_memory");
41017 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41018 0 : return tevent_req_post(req, ev);
41019 : }
41020 :
41021 : /* make a temporary copy, that we pass to the dispatch function */
41022 0 : state->tmp = state->orig;
41023 :
41024 0 : subreq = dcerpc_clusapi_SetGroupSetDependencyExpression_r_send(state, ev, h, &state->tmp);
41025 0 : if (tevent_req_nomem(subreq, req)) {
41026 0 : return tevent_req_post(req, ev);
41027 : }
41028 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_SetGroupSetDependencyExpression_done, req);
41029 0 : return req;
41030 : }
41031 :
41032 0 : static void dcerpc_clusapi_SetGroupSetDependencyExpression_done(struct tevent_req *subreq)
41033 : {
41034 0 : struct tevent_req *req = tevent_req_callback_data(
41035 : subreq, struct tevent_req);
41036 0 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_state *state = tevent_req_data(
41037 : req, struct dcerpc_clusapi_SetGroupSetDependencyExpression_state);
41038 : NTSTATUS status;
41039 : TALLOC_CTX *mem_ctx;
41040 :
41041 0 : if (state->out_mem_ctx) {
41042 0 : mem_ctx = state->out_mem_ctx;
41043 : } else {
41044 0 : mem_ctx = state;
41045 : }
41046 :
41047 0 : status = dcerpc_clusapi_SetGroupSetDependencyExpression_r_recv(subreq, mem_ctx);
41048 0 : TALLOC_FREE(subreq);
41049 0 : if (tevent_req_nterror(req, status)) {
41050 0 : return;
41051 : }
41052 :
41053 : /* Copy out parameters */
41054 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
41055 :
41056 : /* Copy result */
41057 0 : state->orig.out.result = state->tmp.out.result;
41058 :
41059 : /* Reset temporary structure */
41060 0 : NDR_ZERO_STRUCT(state->tmp);
41061 :
41062 0 : tevent_req_done(req);
41063 : }
41064 :
41065 0 : NTSTATUS dcerpc_clusapi_SetGroupSetDependencyExpression_recv(struct tevent_req *req,
41066 : TALLOC_CTX *mem_ctx,
41067 : WERROR *result)
41068 : {
41069 0 : struct dcerpc_clusapi_SetGroupSetDependencyExpression_state *state = tevent_req_data(
41070 : req, struct dcerpc_clusapi_SetGroupSetDependencyExpression_state);
41071 : NTSTATUS status;
41072 :
41073 0 : if (tevent_req_is_nterror(req, &status)) {
41074 0 : tevent_req_received(req);
41075 0 : return status;
41076 : }
41077 :
41078 : /* Steal possible out parameters to the callers context */
41079 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41080 :
41081 : /* Return result */
41082 0 : *result = state->orig.out.result;
41083 :
41084 0 : tevent_req_received(req);
41085 0 : return NT_STATUS_OK;
41086 : }
41087 :
41088 0 : NTSTATUS dcerpc_clusapi_SetGroupSetDependencyExpression(struct dcerpc_binding_handle *h,
41089 : TALLOC_CTX *mem_ctx,
41090 : struct policy_handle _hGroupSet /* [in] */,
41091 : const char *_lpszDependencyExpression /* [in] [charset(UTF16),ref] */,
41092 : WERROR *_rpc_status /* [out] [ref] */,
41093 : WERROR *result)
41094 : {
41095 : struct clusapi_SetGroupSetDependencyExpression r;
41096 : NTSTATUS status;
41097 :
41098 : /* In parameters */
41099 0 : r.in.hGroupSet = _hGroupSet;
41100 0 : r.in.lpszDependencyExpression = _lpszDependencyExpression;
41101 :
41102 : /* Out parameters */
41103 0 : r.out.rpc_status = _rpc_status;
41104 :
41105 : /* Result */
41106 0 : NDR_ZERO_STRUCT(r.out.result);
41107 :
41108 0 : status = dcerpc_clusapi_SetGroupSetDependencyExpression_r(h, mem_ctx, &r);
41109 0 : if (!NT_STATUS_IS_OK(status)) {
41110 0 : return status;
41111 : }
41112 :
41113 : /* Return variables */
41114 0 : *_rpc_status = *r.out.rpc_status;
41115 :
41116 : /* Return result */
41117 0 : *result = r.out.result;
41118 :
41119 0 : return NT_STATUS_OK;
41120 : }
41121 :
41122 : struct dcerpc_clusapi_RemoveGroupSetDependency_r_state {
41123 : TALLOC_CTX *out_mem_ctx;
41124 : };
41125 :
41126 : static void dcerpc_clusapi_RemoveGroupSetDependency_r_done(struct tevent_req *subreq);
41127 :
41128 0 : struct tevent_req *dcerpc_clusapi_RemoveGroupSetDependency_r_send(TALLOC_CTX *mem_ctx,
41129 : struct tevent_context *ev,
41130 : struct dcerpc_binding_handle *h,
41131 : struct clusapi_RemoveGroupSetDependency *r)
41132 : {
41133 : struct tevent_req *req;
41134 : struct dcerpc_clusapi_RemoveGroupSetDependency_r_state *state;
41135 : struct tevent_req *subreq;
41136 :
41137 0 : req = tevent_req_create(mem_ctx, &state,
41138 : struct dcerpc_clusapi_RemoveGroupSetDependency_r_state);
41139 0 : if (req == NULL) {
41140 0 : return NULL;
41141 : }
41142 :
41143 0 : state->out_mem_ctx = talloc_new(state);
41144 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41145 0 : return tevent_req_post(req, ev);
41146 : }
41147 :
41148 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
41149 : NULL, &ndr_table_clusapi,
41150 0 : NDR_CLUSAPI_REMOVEGROUPSETDEPENDENCY, state->out_mem_ctx, r);
41151 0 : if (tevent_req_nomem(subreq, req)) {
41152 0 : return tevent_req_post(req, ev);
41153 : }
41154 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveGroupSetDependency_r_done, req);
41155 :
41156 0 : return req;
41157 : }
41158 :
41159 0 : static void dcerpc_clusapi_RemoveGroupSetDependency_r_done(struct tevent_req *subreq)
41160 : {
41161 0 : struct tevent_req *req =
41162 0 : tevent_req_callback_data(subreq,
41163 : struct tevent_req);
41164 : NTSTATUS status;
41165 :
41166 0 : status = dcerpc_binding_handle_call_recv(subreq);
41167 0 : TALLOC_FREE(subreq);
41168 0 : if (tevent_req_nterror(req, status)) {
41169 0 : return;
41170 : }
41171 :
41172 0 : tevent_req_done(req);
41173 : }
41174 :
41175 0 : NTSTATUS dcerpc_clusapi_RemoveGroupSetDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
41176 : {
41177 0 : struct dcerpc_clusapi_RemoveGroupSetDependency_r_state *state =
41178 0 : tevent_req_data(req,
41179 : struct dcerpc_clusapi_RemoveGroupSetDependency_r_state);
41180 : NTSTATUS status;
41181 :
41182 0 : if (tevent_req_is_nterror(req, &status)) {
41183 0 : tevent_req_received(req);
41184 0 : return status;
41185 : }
41186 :
41187 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41188 :
41189 0 : tevent_req_received(req);
41190 0 : return NT_STATUS_OK;
41191 : }
41192 :
41193 0 : NTSTATUS dcerpc_clusapi_RemoveGroupSetDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveGroupSetDependency *r)
41194 : {
41195 : NTSTATUS status;
41196 :
41197 0 : status = dcerpc_binding_handle_call(h,
41198 : NULL, &ndr_table_clusapi,
41199 : NDR_CLUSAPI_REMOVEGROUPSETDEPENDENCY, mem_ctx, r);
41200 :
41201 0 : return status;
41202 : }
41203 :
41204 : struct dcerpc_clusapi_RemoveGroupSetDependency_state {
41205 : struct clusapi_RemoveGroupSetDependency orig;
41206 : struct clusapi_RemoveGroupSetDependency tmp;
41207 : TALLOC_CTX *out_mem_ctx;
41208 : };
41209 :
41210 : static void dcerpc_clusapi_RemoveGroupSetDependency_done(struct tevent_req *subreq);
41211 :
41212 0 : struct tevent_req *dcerpc_clusapi_RemoveGroupSetDependency_send(TALLOC_CTX *mem_ctx,
41213 : struct tevent_context *ev,
41214 : struct dcerpc_binding_handle *h,
41215 : struct policy_handle _hGroupSet /* [in] */,
41216 : struct policy_handle _hDependsOn /* [in] */,
41217 : WERROR *_rpc_status /* [out] [ref] */)
41218 : {
41219 : struct tevent_req *req;
41220 : struct dcerpc_clusapi_RemoveGroupSetDependency_state *state;
41221 : struct tevent_req *subreq;
41222 :
41223 0 : req = tevent_req_create(mem_ctx, &state,
41224 : struct dcerpc_clusapi_RemoveGroupSetDependency_state);
41225 0 : if (req == NULL) {
41226 0 : return NULL;
41227 : }
41228 0 : state->out_mem_ctx = NULL;
41229 :
41230 : /* In parameters */
41231 0 : state->orig.in.hGroupSet = _hGroupSet;
41232 0 : state->orig.in.hDependsOn = _hDependsOn;
41233 :
41234 : /* Out parameters */
41235 0 : state->orig.out.rpc_status = _rpc_status;
41236 :
41237 : /* Result */
41238 0 : NDR_ZERO_STRUCT(state->orig.out.result);
41239 :
41240 0 : state->out_mem_ctx = talloc_named_const(state, 0,
41241 : "dcerpc_clusapi_RemoveGroupSetDependency_out_memory");
41242 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41243 0 : return tevent_req_post(req, ev);
41244 : }
41245 :
41246 : /* make a temporary copy, that we pass to the dispatch function */
41247 0 : state->tmp = state->orig;
41248 :
41249 0 : subreq = dcerpc_clusapi_RemoveGroupSetDependency_r_send(state, ev, h, &state->tmp);
41250 0 : if (tevent_req_nomem(subreq, req)) {
41251 0 : return tevent_req_post(req, ev);
41252 : }
41253 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveGroupSetDependency_done, req);
41254 0 : return req;
41255 : }
41256 :
41257 0 : static void dcerpc_clusapi_RemoveGroupSetDependency_done(struct tevent_req *subreq)
41258 : {
41259 0 : struct tevent_req *req = tevent_req_callback_data(
41260 : subreq, struct tevent_req);
41261 0 : struct dcerpc_clusapi_RemoveGroupSetDependency_state *state = tevent_req_data(
41262 : req, struct dcerpc_clusapi_RemoveGroupSetDependency_state);
41263 : NTSTATUS status;
41264 : TALLOC_CTX *mem_ctx;
41265 :
41266 0 : if (state->out_mem_ctx) {
41267 0 : mem_ctx = state->out_mem_ctx;
41268 : } else {
41269 0 : mem_ctx = state;
41270 : }
41271 :
41272 0 : status = dcerpc_clusapi_RemoveGroupSetDependency_r_recv(subreq, mem_ctx);
41273 0 : TALLOC_FREE(subreq);
41274 0 : if (tevent_req_nterror(req, status)) {
41275 0 : return;
41276 : }
41277 :
41278 : /* Copy out parameters */
41279 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
41280 :
41281 : /* Copy result */
41282 0 : state->orig.out.result = state->tmp.out.result;
41283 :
41284 : /* Reset temporary structure */
41285 0 : NDR_ZERO_STRUCT(state->tmp);
41286 :
41287 0 : tevent_req_done(req);
41288 : }
41289 :
41290 0 : NTSTATUS dcerpc_clusapi_RemoveGroupSetDependency_recv(struct tevent_req *req,
41291 : TALLOC_CTX *mem_ctx,
41292 : WERROR *result)
41293 : {
41294 0 : struct dcerpc_clusapi_RemoveGroupSetDependency_state *state = tevent_req_data(
41295 : req, struct dcerpc_clusapi_RemoveGroupSetDependency_state);
41296 : NTSTATUS status;
41297 :
41298 0 : if (tevent_req_is_nterror(req, &status)) {
41299 0 : tevent_req_received(req);
41300 0 : return status;
41301 : }
41302 :
41303 : /* Steal possible out parameters to the callers context */
41304 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41305 :
41306 : /* Return result */
41307 0 : *result = state->orig.out.result;
41308 :
41309 0 : tevent_req_received(req);
41310 0 : return NT_STATUS_OK;
41311 : }
41312 :
41313 0 : NTSTATUS dcerpc_clusapi_RemoveGroupSetDependency(struct dcerpc_binding_handle *h,
41314 : TALLOC_CTX *mem_ctx,
41315 : struct policy_handle _hGroupSet /* [in] */,
41316 : struct policy_handle _hDependsOn /* [in] */,
41317 : WERROR *_rpc_status /* [out] [ref] */,
41318 : WERROR *result)
41319 : {
41320 : struct clusapi_RemoveGroupSetDependency r;
41321 : NTSTATUS status;
41322 :
41323 : /* In parameters */
41324 0 : r.in.hGroupSet = _hGroupSet;
41325 0 : r.in.hDependsOn = _hDependsOn;
41326 :
41327 : /* Out parameters */
41328 0 : r.out.rpc_status = _rpc_status;
41329 :
41330 : /* Result */
41331 0 : NDR_ZERO_STRUCT(r.out.result);
41332 :
41333 0 : status = dcerpc_clusapi_RemoveGroupSetDependency_r(h, mem_ctx, &r);
41334 0 : if (!NT_STATUS_IS_OK(status)) {
41335 0 : return status;
41336 : }
41337 :
41338 : /* Return variables */
41339 0 : *_rpc_status = *r.out.rpc_status;
41340 :
41341 : /* Return result */
41342 0 : *result = r.out.result;
41343 :
41344 0 : return NT_STATUS_OK;
41345 : }
41346 :
41347 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_state {
41348 : TALLOC_CTX *out_mem_ctx;
41349 : };
41350 :
41351 : static void dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_done(struct tevent_req *subreq);
41352 :
41353 0 : struct tevent_req *dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_send(TALLOC_CTX *mem_ctx,
41354 : struct tevent_context *ev,
41355 : struct dcerpc_binding_handle *h,
41356 : struct clusapi_RemoveClusterGroupToGroupSetDependency *r)
41357 : {
41358 : struct tevent_req *req;
41359 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_state *state;
41360 : struct tevent_req *subreq;
41361 :
41362 0 : req = tevent_req_create(mem_ctx, &state,
41363 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_state);
41364 0 : if (req == NULL) {
41365 0 : return NULL;
41366 : }
41367 :
41368 0 : state->out_mem_ctx = talloc_new(state);
41369 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41370 0 : return tevent_req_post(req, ev);
41371 : }
41372 :
41373 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
41374 : NULL, &ndr_table_clusapi,
41375 0 : NDR_CLUSAPI_REMOVECLUSTERGROUPTOGROUPSETDEPENDENCY, state->out_mem_ctx, r);
41376 0 : if (tevent_req_nomem(subreq, req)) {
41377 0 : return tevent_req_post(req, ev);
41378 : }
41379 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_done, req);
41380 :
41381 0 : return req;
41382 : }
41383 :
41384 0 : static void dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_done(struct tevent_req *subreq)
41385 : {
41386 0 : struct tevent_req *req =
41387 0 : tevent_req_callback_data(subreq,
41388 : struct tevent_req);
41389 : NTSTATUS status;
41390 :
41391 0 : status = dcerpc_binding_handle_call_recv(subreq);
41392 0 : TALLOC_FREE(subreq);
41393 0 : if (tevent_req_nterror(req, status)) {
41394 0 : return;
41395 : }
41396 :
41397 0 : tevent_req_done(req);
41398 : }
41399 :
41400 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
41401 : {
41402 0 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_state *state =
41403 0 : tevent_req_data(req,
41404 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_state);
41405 : NTSTATUS status;
41406 :
41407 0 : if (tevent_req_is_nterror(req, &status)) {
41408 0 : tevent_req_received(req);
41409 0 : return status;
41410 : }
41411 :
41412 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41413 :
41414 0 : tevent_req_received(req);
41415 0 : return NT_STATUS_OK;
41416 : }
41417 :
41418 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_RemoveClusterGroupToGroupSetDependency *r)
41419 : {
41420 : NTSTATUS status;
41421 :
41422 0 : status = dcerpc_binding_handle_call(h,
41423 : NULL, &ndr_table_clusapi,
41424 : NDR_CLUSAPI_REMOVECLUSTERGROUPTOGROUPSETDEPENDENCY, mem_ctx, r);
41425 :
41426 0 : return status;
41427 : }
41428 :
41429 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state {
41430 : struct clusapi_RemoveClusterGroupToGroupSetDependency orig;
41431 : struct clusapi_RemoveClusterGroupToGroupSetDependency tmp;
41432 : TALLOC_CTX *out_mem_ctx;
41433 : };
41434 :
41435 : static void dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_done(struct tevent_req *subreq);
41436 :
41437 0 : struct tevent_req *dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_send(TALLOC_CTX *mem_ctx,
41438 : struct tevent_context *ev,
41439 : struct dcerpc_binding_handle *h,
41440 : struct policy_handle _hGroup /* [in] */,
41441 : struct policy_handle _hDependsOn /* [in] */,
41442 : WERROR *_rpc_status /* [out] [ref] */)
41443 : {
41444 : struct tevent_req *req;
41445 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state *state;
41446 : struct tevent_req *subreq;
41447 :
41448 0 : req = tevent_req_create(mem_ctx, &state,
41449 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state);
41450 0 : if (req == NULL) {
41451 0 : return NULL;
41452 : }
41453 0 : state->out_mem_ctx = NULL;
41454 :
41455 : /* In parameters */
41456 0 : state->orig.in.hGroup = _hGroup;
41457 0 : state->orig.in.hDependsOn = _hDependsOn;
41458 :
41459 : /* Out parameters */
41460 0 : state->orig.out.rpc_status = _rpc_status;
41461 :
41462 : /* Result */
41463 0 : NDR_ZERO_STRUCT(state->orig.out.result);
41464 :
41465 0 : state->out_mem_ctx = talloc_named_const(state, 0,
41466 : "dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_out_memory");
41467 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41468 0 : return tevent_req_post(req, ev);
41469 : }
41470 :
41471 : /* make a temporary copy, that we pass to the dispatch function */
41472 0 : state->tmp = state->orig;
41473 :
41474 0 : subreq = dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_send(state, ev, h, &state->tmp);
41475 0 : if (tevent_req_nomem(subreq, req)) {
41476 0 : return tevent_req_post(req, ev);
41477 : }
41478 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_done, req);
41479 0 : return req;
41480 : }
41481 :
41482 0 : static void dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_done(struct tevent_req *subreq)
41483 : {
41484 0 : struct tevent_req *req = tevent_req_callback_data(
41485 : subreq, struct tevent_req);
41486 0 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state *state = tevent_req_data(
41487 : req, struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state);
41488 : NTSTATUS status;
41489 : TALLOC_CTX *mem_ctx;
41490 :
41491 0 : if (state->out_mem_ctx) {
41492 0 : mem_ctx = state->out_mem_ctx;
41493 : } else {
41494 0 : mem_ctx = state;
41495 : }
41496 :
41497 0 : status = dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r_recv(subreq, mem_ctx);
41498 0 : TALLOC_FREE(subreq);
41499 0 : if (tevent_req_nterror(req, status)) {
41500 0 : return;
41501 : }
41502 :
41503 : /* Copy out parameters */
41504 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
41505 :
41506 : /* Copy result */
41507 0 : state->orig.out.result = state->tmp.out.result;
41508 :
41509 : /* Reset temporary structure */
41510 0 : NDR_ZERO_STRUCT(state->tmp);
41511 :
41512 0 : tevent_req_done(req);
41513 : }
41514 :
41515 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_recv(struct tevent_req *req,
41516 : TALLOC_CTX *mem_ctx,
41517 : WERROR *result)
41518 : {
41519 0 : struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state *state = tevent_req_data(
41520 : req, struct dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_state);
41521 : NTSTATUS status;
41522 :
41523 0 : if (tevent_req_is_nterror(req, &status)) {
41524 0 : tevent_req_received(req);
41525 0 : return status;
41526 : }
41527 :
41528 : /* Steal possible out parameters to the callers context */
41529 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41530 :
41531 : /* Return result */
41532 0 : *result = state->orig.out.result;
41533 :
41534 0 : tevent_req_received(req);
41535 0 : return NT_STATUS_OK;
41536 : }
41537 :
41538 0 : NTSTATUS dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency(struct dcerpc_binding_handle *h,
41539 : TALLOC_CTX *mem_ctx,
41540 : struct policy_handle _hGroup /* [in] */,
41541 : struct policy_handle _hDependsOn /* [in] */,
41542 : WERROR *_rpc_status /* [out] [ref] */,
41543 : WERROR *result)
41544 : {
41545 : struct clusapi_RemoveClusterGroupToGroupSetDependency r;
41546 : NTSTATUS status;
41547 :
41548 : /* In parameters */
41549 0 : r.in.hGroup = _hGroup;
41550 0 : r.in.hDependsOn = _hDependsOn;
41551 :
41552 : /* Out parameters */
41553 0 : r.out.rpc_status = _rpc_status;
41554 :
41555 : /* Result */
41556 0 : NDR_ZERO_STRUCT(r.out.result);
41557 :
41558 0 : status = dcerpc_clusapi_RemoveClusterGroupToGroupSetDependency_r(h, mem_ctx, &r);
41559 0 : if (!NT_STATUS_IS_OK(status)) {
41560 0 : return status;
41561 : }
41562 :
41563 : /* Return variables */
41564 0 : *_rpc_status = *r.out.rpc_status;
41565 :
41566 : /* Return result */
41567 0 : *result = r.out.result;
41568 :
41569 0 : return NT_STATUS_OK;
41570 : }
41571 :
41572 : struct dcerpc_clusapi_CreateGroupSetEnum_r_state {
41573 : TALLOC_CTX *out_mem_ctx;
41574 : };
41575 :
41576 : static void dcerpc_clusapi_CreateGroupSetEnum_r_done(struct tevent_req *subreq);
41577 :
41578 0 : struct tevent_req *dcerpc_clusapi_CreateGroupSetEnum_r_send(TALLOC_CTX *mem_ctx,
41579 : struct tevent_context *ev,
41580 : struct dcerpc_binding_handle *h,
41581 : struct clusapi_CreateGroupSetEnum *r)
41582 : {
41583 : struct tevent_req *req;
41584 : struct dcerpc_clusapi_CreateGroupSetEnum_r_state *state;
41585 : struct tevent_req *subreq;
41586 :
41587 0 : req = tevent_req_create(mem_ctx, &state,
41588 : struct dcerpc_clusapi_CreateGroupSetEnum_r_state);
41589 0 : if (req == NULL) {
41590 0 : return NULL;
41591 : }
41592 :
41593 0 : state->out_mem_ctx = talloc_new(state);
41594 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41595 0 : return tevent_req_post(req, ev);
41596 : }
41597 :
41598 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
41599 : NULL, &ndr_table_clusapi,
41600 0 : NDR_CLUSAPI_CREATEGROUPSETENUM, state->out_mem_ctx, r);
41601 0 : if (tevent_req_nomem(subreq, req)) {
41602 0 : return tevent_req_post(req, ev);
41603 : }
41604 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupSetEnum_r_done, req);
41605 :
41606 0 : return req;
41607 : }
41608 :
41609 0 : static void dcerpc_clusapi_CreateGroupSetEnum_r_done(struct tevent_req *subreq)
41610 : {
41611 0 : struct tevent_req *req =
41612 0 : tevent_req_callback_data(subreq,
41613 : struct tevent_req);
41614 : NTSTATUS status;
41615 :
41616 0 : status = dcerpc_binding_handle_call_recv(subreq);
41617 0 : TALLOC_FREE(subreq);
41618 0 : if (tevent_req_nterror(req, status)) {
41619 0 : return;
41620 : }
41621 :
41622 0 : tevent_req_done(req);
41623 : }
41624 :
41625 0 : NTSTATUS dcerpc_clusapi_CreateGroupSetEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
41626 : {
41627 0 : struct dcerpc_clusapi_CreateGroupSetEnum_r_state *state =
41628 0 : tevent_req_data(req,
41629 : struct dcerpc_clusapi_CreateGroupSetEnum_r_state);
41630 : NTSTATUS status;
41631 :
41632 0 : if (tevent_req_is_nterror(req, &status)) {
41633 0 : tevent_req_received(req);
41634 0 : return status;
41635 : }
41636 :
41637 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41638 :
41639 0 : tevent_req_received(req);
41640 0 : return NT_STATUS_OK;
41641 : }
41642 :
41643 0 : NTSTATUS dcerpc_clusapi_CreateGroupSetEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateGroupSetEnum *r)
41644 : {
41645 : NTSTATUS status;
41646 :
41647 0 : status = dcerpc_binding_handle_call(h,
41648 : NULL, &ndr_table_clusapi,
41649 : NDR_CLUSAPI_CREATEGROUPSETENUM, mem_ctx, r);
41650 :
41651 0 : return status;
41652 : }
41653 :
41654 : struct dcerpc_clusapi_CreateGroupSetEnum_state {
41655 : struct clusapi_CreateGroupSetEnum orig;
41656 : struct clusapi_CreateGroupSetEnum tmp;
41657 : TALLOC_CTX *out_mem_ctx;
41658 : };
41659 :
41660 : static void dcerpc_clusapi_CreateGroupSetEnum_done(struct tevent_req *subreq);
41661 :
41662 0 : struct tevent_req *dcerpc_clusapi_CreateGroupSetEnum_send(TALLOC_CTX *mem_ctx,
41663 : struct tevent_context *ev,
41664 : struct dcerpc_binding_handle *h,
41665 : struct policy_handle _hCluster /* [in] */,
41666 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
41667 : WERROR *_rpc_status /* [out] [ref] */)
41668 : {
41669 : struct tevent_req *req;
41670 : struct dcerpc_clusapi_CreateGroupSetEnum_state *state;
41671 : struct tevent_req *subreq;
41672 :
41673 0 : req = tevent_req_create(mem_ctx, &state,
41674 : struct dcerpc_clusapi_CreateGroupSetEnum_state);
41675 0 : if (req == NULL) {
41676 0 : return NULL;
41677 : }
41678 0 : state->out_mem_ctx = NULL;
41679 :
41680 : /* In parameters */
41681 0 : state->orig.in.hCluster = _hCluster;
41682 :
41683 : /* Out parameters */
41684 0 : state->orig.out.ReturnEnum = _ReturnEnum;
41685 0 : state->orig.out.rpc_status = _rpc_status;
41686 :
41687 : /* Result */
41688 0 : NDR_ZERO_STRUCT(state->orig.out.result);
41689 :
41690 0 : state->out_mem_ctx = talloc_named_const(state, 0,
41691 : "dcerpc_clusapi_CreateGroupSetEnum_out_memory");
41692 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41693 0 : return tevent_req_post(req, ev);
41694 : }
41695 :
41696 : /* make a temporary copy, that we pass to the dispatch function */
41697 0 : state->tmp = state->orig;
41698 :
41699 0 : subreq = dcerpc_clusapi_CreateGroupSetEnum_r_send(state, ev, h, &state->tmp);
41700 0 : if (tevent_req_nomem(subreq, req)) {
41701 0 : return tevent_req_post(req, ev);
41702 : }
41703 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateGroupSetEnum_done, req);
41704 0 : return req;
41705 : }
41706 :
41707 0 : static void dcerpc_clusapi_CreateGroupSetEnum_done(struct tevent_req *subreq)
41708 : {
41709 0 : struct tevent_req *req = tevent_req_callback_data(
41710 : subreq, struct tevent_req);
41711 0 : struct dcerpc_clusapi_CreateGroupSetEnum_state *state = tevent_req_data(
41712 : req, struct dcerpc_clusapi_CreateGroupSetEnum_state);
41713 : NTSTATUS status;
41714 : TALLOC_CTX *mem_ctx;
41715 :
41716 0 : if (state->out_mem_ctx) {
41717 0 : mem_ctx = state->out_mem_ctx;
41718 : } else {
41719 0 : mem_ctx = state;
41720 : }
41721 :
41722 0 : status = dcerpc_clusapi_CreateGroupSetEnum_r_recv(subreq, mem_ctx);
41723 0 : TALLOC_FREE(subreq);
41724 0 : if (tevent_req_nterror(req, status)) {
41725 0 : return;
41726 : }
41727 :
41728 : /* Copy out parameters */
41729 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
41730 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
41731 :
41732 : /* Copy result */
41733 0 : state->orig.out.result = state->tmp.out.result;
41734 :
41735 : /* Reset temporary structure */
41736 0 : NDR_ZERO_STRUCT(state->tmp);
41737 :
41738 0 : tevent_req_done(req);
41739 : }
41740 :
41741 0 : NTSTATUS dcerpc_clusapi_CreateGroupSetEnum_recv(struct tevent_req *req,
41742 : TALLOC_CTX *mem_ctx,
41743 : WERROR *result)
41744 : {
41745 0 : struct dcerpc_clusapi_CreateGroupSetEnum_state *state = tevent_req_data(
41746 : req, struct dcerpc_clusapi_CreateGroupSetEnum_state);
41747 : NTSTATUS status;
41748 :
41749 0 : if (tevent_req_is_nterror(req, &status)) {
41750 0 : tevent_req_received(req);
41751 0 : return status;
41752 : }
41753 :
41754 : /* Steal possible out parameters to the callers context */
41755 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41756 :
41757 : /* Return result */
41758 0 : *result = state->orig.out.result;
41759 :
41760 0 : tevent_req_received(req);
41761 0 : return NT_STATUS_OK;
41762 : }
41763 :
41764 0 : NTSTATUS dcerpc_clusapi_CreateGroupSetEnum(struct dcerpc_binding_handle *h,
41765 : TALLOC_CTX *mem_ctx,
41766 : struct policy_handle _hCluster /* [in] */,
41767 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
41768 : WERROR *_rpc_status /* [out] [ref] */,
41769 : WERROR *result)
41770 : {
41771 : struct clusapi_CreateGroupSetEnum r;
41772 : NTSTATUS status;
41773 :
41774 : /* In parameters */
41775 0 : r.in.hCluster = _hCluster;
41776 :
41777 : /* Out parameters */
41778 0 : r.out.ReturnEnum = _ReturnEnum;
41779 0 : r.out.rpc_status = _rpc_status;
41780 :
41781 : /* Result */
41782 0 : NDR_ZERO_STRUCT(r.out.result);
41783 :
41784 0 : status = dcerpc_clusapi_CreateGroupSetEnum_r(h, mem_ctx, &r);
41785 0 : if (!NT_STATUS_IS_OK(status)) {
41786 0 : return status;
41787 : }
41788 :
41789 : /* Return variables */
41790 0 : *_ReturnEnum = *r.out.ReturnEnum;
41791 0 : *_rpc_status = *r.out.rpc_status;
41792 :
41793 : /* Return result */
41794 0 : *result = r.out.result;
41795 :
41796 0 : return NT_STATUS_OK;
41797 : }
41798 :
41799 : struct dcerpc_clusapi_CreateNetInterfaceEnum_r_state {
41800 : TALLOC_CTX *out_mem_ctx;
41801 : };
41802 :
41803 : static void dcerpc_clusapi_CreateNetInterfaceEnum_r_done(struct tevent_req *subreq);
41804 :
41805 0 : struct tevent_req *dcerpc_clusapi_CreateNetInterfaceEnum_r_send(TALLOC_CTX *mem_ctx,
41806 : struct tevent_context *ev,
41807 : struct dcerpc_binding_handle *h,
41808 : struct clusapi_CreateNetInterfaceEnum *r)
41809 : {
41810 : struct tevent_req *req;
41811 : struct dcerpc_clusapi_CreateNetInterfaceEnum_r_state *state;
41812 : struct tevent_req *subreq;
41813 :
41814 0 : req = tevent_req_create(mem_ctx, &state,
41815 : struct dcerpc_clusapi_CreateNetInterfaceEnum_r_state);
41816 0 : if (req == NULL) {
41817 0 : return NULL;
41818 : }
41819 :
41820 0 : state->out_mem_ctx = talloc_new(state);
41821 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41822 0 : return tevent_req_post(req, ev);
41823 : }
41824 :
41825 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
41826 : NULL, &ndr_table_clusapi,
41827 0 : NDR_CLUSAPI_CREATENETINTERFACEENUM, state->out_mem_ctx, r);
41828 0 : if (tevent_req_nomem(subreq, req)) {
41829 0 : return tevent_req_post(req, ev);
41830 : }
41831 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNetInterfaceEnum_r_done, req);
41832 :
41833 0 : return req;
41834 : }
41835 :
41836 0 : static void dcerpc_clusapi_CreateNetInterfaceEnum_r_done(struct tevent_req *subreq)
41837 : {
41838 0 : struct tevent_req *req =
41839 0 : tevent_req_callback_data(subreq,
41840 : struct tevent_req);
41841 : NTSTATUS status;
41842 :
41843 0 : status = dcerpc_binding_handle_call_recv(subreq);
41844 0 : TALLOC_FREE(subreq);
41845 0 : if (tevent_req_nterror(req, status)) {
41846 0 : return;
41847 : }
41848 :
41849 0 : tevent_req_done(req);
41850 : }
41851 :
41852 0 : NTSTATUS dcerpc_clusapi_CreateNetInterfaceEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
41853 : {
41854 0 : struct dcerpc_clusapi_CreateNetInterfaceEnum_r_state *state =
41855 0 : tevent_req_data(req,
41856 : struct dcerpc_clusapi_CreateNetInterfaceEnum_r_state);
41857 : NTSTATUS status;
41858 :
41859 0 : if (tevent_req_is_nterror(req, &status)) {
41860 0 : tevent_req_received(req);
41861 0 : return status;
41862 : }
41863 :
41864 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41865 :
41866 0 : tevent_req_received(req);
41867 0 : return NT_STATUS_OK;
41868 : }
41869 :
41870 0 : NTSTATUS dcerpc_clusapi_CreateNetInterfaceEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_CreateNetInterfaceEnum *r)
41871 : {
41872 : NTSTATUS status;
41873 :
41874 0 : status = dcerpc_binding_handle_call(h,
41875 : NULL, &ndr_table_clusapi,
41876 : NDR_CLUSAPI_CREATENETINTERFACEENUM, mem_ctx, r);
41877 :
41878 0 : return status;
41879 : }
41880 :
41881 : struct dcerpc_clusapi_CreateNetInterfaceEnum_state {
41882 : struct clusapi_CreateNetInterfaceEnum orig;
41883 : struct clusapi_CreateNetInterfaceEnum tmp;
41884 : TALLOC_CTX *out_mem_ctx;
41885 : };
41886 :
41887 : static void dcerpc_clusapi_CreateNetInterfaceEnum_done(struct tevent_req *subreq);
41888 :
41889 0 : struct tevent_req *dcerpc_clusapi_CreateNetInterfaceEnum_send(TALLOC_CTX *mem_ctx,
41890 : struct tevent_context *ev,
41891 : struct dcerpc_binding_handle *h,
41892 : struct policy_handle _hCluster /* [in] */,
41893 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
41894 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
41895 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
41896 : WERROR *_rpc_status /* [out] [ref] */)
41897 : {
41898 : struct tevent_req *req;
41899 : struct dcerpc_clusapi_CreateNetInterfaceEnum_state *state;
41900 : struct tevent_req *subreq;
41901 :
41902 0 : req = tevent_req_create(mem_ctx, &state,
41903 : struct dcerpc_clusapi_CreateNetInterfaceEnum_state);
41904 0 : if (req == NULL) {
41905 0 : return NULL;
41906 : }
41907 0 : state->out_mem_ctx = NULL;
41908 :
41909 : /* In parameters */
41910 0 : state->orig.in.hCluster = _hCluster;
41911 0 : state->orig.in.lpszNodeName = _lpszNodeName;
41912 0 : state->orig.in.lpszNetworkName = _lpszNetworkName;
41913 :
41914 : /* Out parameters */
41915 0 : state->orig.out.ReturnEnum = _ReturnEnum;
41916 0 : state->orig.out.rpc_status = _rpc_status;
41917 :
41918 : /* Result */
41919 0 : NDR_ZERO_STRUCT(state->orig.out.result);
41920 :
41921 0 : state->out_mem_ctx = talloc_named_const(state, 0,
41922 : "dcerpc_clusapi_CreateNetInterfaceEnum_out_memory");
41923 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
41924 0 : return tevent_req_post(req, ev);
41925 : }
41926 :
41927 : /* make a temporary copy, that we pass to the dispatch function */
41928 0 : state->tmp = state->orig;
41929 :
41930 0 : subreq = dcerpc_clusapi_CreateNetInterfaceEnum_r_send(state, ev, h, &state->tmp);
41931 0 : if (tevent_req_nomem(subreq, req)) {
41932 0 : return tevent_req_post(req, ev);
41933 : }
41934 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_CreateNetInterfaceEnum_done, req);
41935 0 : return req;
41936 : }
41937 :
41938 0 : static void dcerpc_clusapi_CreateNetInterfaceEnum_done(struct tevent_req *subreq)
41939 : {
41940 0 : struct tevent_req *req = tevent_req_callback_data(
41941 : subreq, struct tevent_req);
41942 0 : struct dcerpc_clusapi_CreateNetInterfaceEnum_state *state = tevent_req_data(
41943 : req, struct dcerpc_clusapi_CreateNetInterfaceEnum_state);
41944 : NTSTATUS status;
41945 : TALLOC_CTX *mem_ctx;
41946 :
41947 0 : if (state->out_mem_ctx) {
41948 0 : mem_ctx = state->out_mem_ctx;
41949 : } else {
41950 0 : mem_ctx = state;
41951 : }
41952 :
41953 0 : status = dcerpc_clusapi_CreateNetInterfaceEnum_r_recv(subreq, mem_ctx);
41954 0 : TALLOC_FREE(subreq);
41955 0 : if (tevent_req_nterror(req, status)) {
41956 0 : return;
41957 : }
41958 :
41959 : /* Copy out parameters */
41960 0 : *state->orig.out.ReturnEnum = *state->tmp.out.ReturnEnum;
41961 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
41962 :
41963 : /* Copy result */
41964 0 : state->orig.out.result = state->tmp.out.result;
41965 :
41966 : /* Reset temporary structure */
41967 0 : NDR_ZERO_STRUCT(state->tmp);
41968 :
41969 0 : tevent_req_done(req);
41970 : }
41971 :
41972 0 : NTSTATUS dcerpc_clusapi_CreateNetInterfaceEnum_recv(struct tevent_req *req,
41973 : TALLOC_CTX *mem_ctx,
41974 : WERROR *result)
41975 : {
41976 0 : struct dcerpc_clusapi_CreateNetInterfaceEnum_state *state = tevent_req_data(
41977 : req, struct dcerpc_clusapi_CreateNetInterfaceEnum_state);
41978 : NTSTATUS status;
41979 :
41980 0 : if (tevent_req_is_nterror(req, &status)) {
41981 0 : tevent_req_received(req);
41982 0 : return status;
41983 : }
41984 :
41985 : /* Steal possible out parameters to the callers context */
41986 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
41987 :
41988 : /* Return result */
41989 0 : *result = state->orig.out.result;
41990 :
41991 0 : tevent_req_received(req);
41992 0 : return NT_STATUS_OK;
41993 : }
41994 :
41995 0 : NTSTATUS dcerpc_clusapi_CreateNetInterfaceEnum(struct dcerpc_binding_handle *h,
41996 : TALLOC_CTX *mem_ctx,
41997 : struct policy_handle _hCluster /* [in] */,
41998 : const char *_lpszNodeName /* [in] [charset(UTF16),ref] */,
41999 : const char *_lpszNetworkName /* [in] [charset(UTF16),ref] */,
42000 : struct ENUM_LIST **_ReturnEnum /* [out] [ref] */,
42001 : WERROR *_rpc_status /* [out] [ref] */,
42002 : WERROR *result)
42003 : {
42004 : struct clusapi_CreateNetInterfaceEnum r;
42005 : NTSTATUS status;
42006 :
42007 : /* In parameters */
42008 0 : r.in.hCluster = _hCluster;
42009 0 : r.in.lpszNodeName = _lpszNodeName;
42010 0 : r.in.lpszNetworkName = _lpszNetworkName;
42011 :
42012 : /* Out parameters */
42013 0 : r.out.ReturnEnum = _ReturnEnum;
42014 0 : r.out.rpc_status = _rpc_status;
42015 :
42016 : /* Result */
42017 0 : NDR_ZERO_STRUCT(r.out.result);
42018 :
42019 0 : status = dcerpc_clusapi_CreateNetInterfaceEnum_r(h, mem_ctx, &r);
42020 0 : if (!NT_STATUS_IS_OK(status)) {
42021 0 : return status;
42022 : }
42023 :
42024 : /* Return variables */
42025 0 : *_ReturnEnum = *r.out.ReturnEnum;
42026 0 : *_rpc_status = *r.out.rpc_status;
42027 :
42028 : /* Return result */
42029 0 : *result = r.out.result;
42030 :
42031 0 : return NT_STATUS_OK;
42032 : }
42033 :
42034 : struct dcerpc_clusapi_ChangeCsvStateEx_r_state {
42035 : TALLOC_CTX *out_mem_ctx;
42036 : };
42037 :
42038 : static void dcerpc_clusapi_ChangeCsvStateEx_r_done(struct tevent_req *subreq);
42039 :
42040 0 : struct tevent_req *dcerpc_clusapi_ChangeCsvStateEx_r_send(TALLOC_CTX *mem_ctx,
42041 : struct tevent_context *ev,
42042 : struct dcerpc_binding_handle *h,
42043 : struct clusapi_ChangeCsvStateEx *r)
42044 : {
42045 : struct tevent_req *req;
42046 : struct dcerpc_clusapi_ChangeCsvStateEx_r_state *state;
42047 : struct tevent_req *subreq;
42048 :
42049 0 : req = tevent_req_create(mem_ctx, &state,
42050 : struct dcerpc_clusapi_ChangeCsvStateEx_r_state);
42051 0 : if (req == NULL) {
42052 0 : return NULL;
42053 : }
42054 :
42055 0 : state->out_mem_ctx = talloc_new(state);
42056 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
42057 0 : return tevent_req_post(req, ev);
42058 : }
42059 :
42060 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
42061 : NULL, &ndr_table_clusapi,
42062 0 : NDR_CLUSAPI_CHANGECSVSTATEEX, state->out_mem_ctx, r);
42063 0 : if (tevent_req_nomem(subreq, req)) {
42064 0 : return tevent_req_post(req, ev);
42065 : }
42066 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeCsvStateEx_r_done, req);
42067 :
42068 0 : return req;
42069 : }
42070 :
42071 0 : static void dcerpc_clusapi_ChangeCsvStateEx_r_done(struct tevent_req *subreq)
42072 : {
42073 0 : struct tevent_req *req =
42074 0 : tevent_req_callback_data(subreq,
42075 : struct tevent_req);
42076 : NTSTATUS status;
42077 :
42078 0 : status = dcerpc_binding_handle_call_recv(subreq);
42079 0 : TALLOC_FREE(subreq);
42080 0 : if (tevent_req_nterror(req, status)) {
42081 0 : return;
42082 : }
42083 :
42084 0 : tevent_req_done(req);
42085 : }
42086 :
42087 0 : NTSTATUS dcerpc_clusapi_ChangeCsvStateEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
42088 : {
42089 0 : struct dcerpc_clusapi_ChangeCsvStateEx_r_state *state =
42090 0 : tevent_req_data(req,
42091 : struct dcerpc_clusapi_ChangeCsvStateEx_r_state);
42092 : NTSTATUS status;
42093 :
42094 0 : if (tevent_req_is_nterror(req, &status)) {
42095 0 : tevent_req_received(req);
42096 0 : return status;
42097 : }
42098 :
42099 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
42100 :
42101 0 : tevent_req_received(req);
42102 0 : return NT_STATUS_OK;
42103 : }
42104 :
42105 0 : NTSTATUS dcerpc_clusapi_ChangeCsvStateEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_ChangeCsvStateEx *r)
42106 : {
42107 : NTSTATUS status;
42108 :
42109 0 : status = dcerpc_binding_handle_call(h,
42110 : NULL, &ndr_table_clusapi,
42111 : NDR_CLUSAPI_CHANGECSVSTATEEX, mem_ctx, r);
42112 :
42113 0 : return status;
42114 : }
42115 :
42116 : struct dcerpc_clusapi_ChangeCsvStateEx_state {
42117 : struct clusapi_ChangeCsvStateEx orig;
42118 : struct clusapi_ChangeCsvStateEx tmp;
42119 : TALLOC_CTX *out_mem_ctx;
42120 : };
42121 :
42122 : static void dcerpc_clusapi_ChangeCsvStateEx_done(struct tevent_req *subreq);
42123 :
42124 0 : struct tevent_req *dcerpc_clusapi_ChangeCsvStateEx_send(TALLOC_CTX *mem_ctx,
42125 : struct tevent_context *ev,
42126 : struct dcerpc_binding_handle *h,
42127 : struct policy_handle _hResource /* [in] */,
42128 : uint32_t _dwState /* [in] */,
42129 : const char *_lpszVolumeName /* [in] [charset(UTF16),ref] */,
42130 : WERROR *_rpc_status /* [out] [ref] */)
42131 : {
42132 : struct tevent_req *req;
42133 : struct dcerpc_clusapi_ChangeCsvStateEx_state *state;
42134 : struct tevent_req *subreq;
42135 :
42136 0 : req = tevent_req_create(mem_ctx, &state,
42137 : struct dcerpc_clusapi_ChangeCsvStateEx_state);
42138 0 : if (req == NULL) {
42139 0 : return NULL;
42140 : }
42141 0 : state->out_mem_ctx = NULL;
42142 :
42143 : /* In parameters */
42144 0 : state->orig.in.hResource = _hResource;
42145 0 : state->orig.in.dwState = _dwState;
42146 0 : state->orig.in.lpszVolumeName = _lpszVolumeName;
42147 :
42148 : /* Out parameters */
42149 0 : state->orig.out.rpc_status = _rpc_status;
42150 :
42151 : /* Result */
42152 0 : NDR_ZERO_STRUCT(state->orig.out.result);
42153 :
42154 0 : state->out_mem_ctx = talloc_named_const(state, 0,
42155 : "dcerpc_clusapi_ChangeCsvStateEx_out_memory");
42156 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
42157 0 : return tevent_req_post(req, ev);
42158 : }
42159 :
42160 : /* make a temporary copy, that we pass to the dispatch function */
42161 0 : state->tmp = state->orig;
42162 :
42163 0 : subreq = dcerpc_clusapi_ChangeCsvStateEx_r_send(state, ev, h, &state->tmp);
42164 0 : if (tevent_req_nomem(subreq, req)) {
42165 0 : return tevent_req_post(req, ev);
42166 : }
42167 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_ChangeCsvStateEx_done, req);
42168 0 : return req;
42169 : }
42170 :
42171 0 : static void dcerpc_clusapi_ChangeCsvStateEx_done(struct tevent_req *subreq)
42172 : {
42173 0 : struct tevent_req *req = tevent_req_callback_data(
42174 : subreq, struct tevent_req);
42175 0 : struct dcerpc_clusapi_ChangeCsvStateEx_state *state = tevent_req_data(
42176 : req, struct dcerpc_clusapi_ChangeCsvStateEx_state);
42177 : NTSTATUS status;
42178 : TALLOC_CTX *mem_ctx;
42179 :
42180 0 : if (state->out_mem_ctx) {
42181 0 : mem_ctx = state->out_mem_ctx;
42182 : } else {
42183 0 : mem_ctx = state;
42184 : }
42185 :
42186 0 : status = dcerpc_clusapi_ChangeCsvStateEx_r_recv(subreq, mem_ctx);
42187 0 : TALLOC_FREE(subreq);
42188 0 : if (tevent_req_nterror(req, status)) {
42189 0 : return;
42190 : }
42191 :
42192 : /* Copy out parameters */
42193 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
42194 :
42195 : /* Copy result */
42196 0 : state->orig.out.result = state->tmp.out.result;
42197 :
42198 : /* Reset temporary structure */
42199 0 : NDR_ZERO_STRUCT(state->tmp);
42200 :
42201 0 : tevent_req_done(req);
42202 : }
42203 :
42204 0 : NTSTATUS dcerpc_clusapi_ChangeCsvStateEx_recv(struct tevent_req *req,
42205 : TALLOC_CTX *mem_ctx,
42206 : WERROR *result)
42207 : {
42208 0 : struct dcerpc_clusapi_ChangeCsvStateEx_state *state = tevent_req_data(
42209 : req, struct dcerpc_clusapi_ChangeCsvStateEx_state);
42210 : NTSTATUS status;
42211 :
42212 0 : if (tevent_req_is_nterror(req, &status)) {
42213 0 : tevent_req_received(req);
42214 0 : return status;
42215 : }
42216 :
42217 : /* Steal possible out parameters to the callers context */
42218 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
42219 :
42220 : /* Return result */
42221 0 : *result = state->orig.out.result;
42222 :
42223 0 : tevent_req_received(req);
42224 0 : return NT_STATUS_OK;
42225 : }
42226 :
42227 0 : NTSTATUS dcerpc_clusapi_ChangeCsvStateEx(struct dcerpc_binding_handle *h,
42228 : TALLOC_CTX *mem_ctx,
42229 : struct policy_handle _hResource /* [in] */,
42230 : uint32_t _dwState /* [in] */,
42231 : const char *_lpszVolumeName /* [in] [charset(UTF16),ref] */,
42232 : WERROR *_rpc_status /* [out] [ref] */,
42233 : WERROR *result)
42234 : {
42235 : struct clusapi_ChangeCsvStateEx r;
42236 : NTSTATUS status;
42237 :
42238 : /* In parameters */
42239 0 : r.in.hResource = _hResource;
42240 0 : r.in.dwState = _dwState;
42241 0 : r.in.lpszVolumeName = _lpszVolumeName;
42242 :
42243 : /* Out parameters */
42244 0 : r.out.rpc_status = _rpc_status;
42245 :
42246 : /* Result */
42247 0 : NDR_ZERO_STRUCT(r.out.result);
42248 :
42249 0 : status = dcerpc_clusapi_ChangeCsvStateEx_r(h, mem_ctx, &r);
42250 0 : if (!NT_STATUS_IS_OK(status)) {
42251 0 : return status;
42252 : }
42253 :
42254 : /* Return variables */
42255 0 : *_rpc_status = *r.out.rpc_status;
42256 :
42257 : /* Return result */
42258 0 : *result = r.out.result;
42259 :
42260 0 : return NT_STATUS_OK;
42261 : }
42262 :
42263 : struct dcerpc_clusapi_AddGroupToGroupSetEx_r_state {
42264 : TALLOC_CTX *out_mem_ctx;
42265 : };
42266 :
42267 : static void dcerpc_clusapi_AddGroupToGroupSetEx_r_done(struct tevent_req *subreq);
42268 :
42269 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSetEx_r_send(TALLOC_CTX *mem_ctx,
42270 : struct tevent_context *ev,
42271 : struct dcerpc_binding_handle *h,
42272 : struct clusapi_AddGroupToGroupSetEx *r)
42273 : {
42274 : struct tevent_req *req;
42275 : struct dcerpc_clusapi_AddGroupToGroupSetEx_r_state *state;
42276 : struct tevent_req *subreq;
42277 :
42278 0 : req = tevent_req_create(mem_ctx, &state,
42279 : struct dcerpc_clusapi_AddGroupToGroupSetEx_r_state);
42280 0 : if (req == NULL) {
42281 0 : return NULL;
42282 : }
42283 :
42284 0 : state->out_mem_ctx = talloc_new(state);
42285 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
42286 0 : return tevent_req_post(req, ev);
42287 : }
42288 :
42289 0 : subreq = dcerpc_binding_handle_call_send(state, ev, h,
42290 : NULL, &ndr_table_clusapi,
42291 0 : NDR_CLUSAPI_ADDGROUPTOGROUPSETEX, state->out_mem_ctx, r);
42292 0 : if (tevent_req_nomem(subreq, req)) {
42293 0 : return tevent_req_post(req, ev);
42294 : }
42295 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSetEx_r_done, req);
42296 :
42297 0 : return req;
42298 : }
42299 :
42300 0 : static void dcerpc_clusapi_AddGroupToGroupSetEx_r_done(struct tevent_req *subreq)
42301 : {
42302 0 : struct tevent_req *req =
42303 0 : tevent_req_callback_data(subreq,
42304 : struct tevent_req);
42305 : NTSTATUS status;
42306 :
42307 0 : status = dcerpc_binding_handle_call_recv(subreq);
42308 0 : TALLOC_FREE(subreq);
42309 0 : if (tevent_req_nterror(req, status)) {
42310 0 : return;
42311 : }
42312 :
42313 0 : tevent_req_done(req);
42314 : }
42315 :
42316 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
42317 : {
42318 0 : struct dcerpc_clusapi_AddGroupToGroupSetEx_r_state *state =
42319 0 : tevent_req_data(req,
42320 : struct dcerpc_clusapi_AddGroupToGroupSetEx_r_state);
42321 : NTSTATUS status;
42322 :
42323 0 : if (tevent_req_is_nterror(req, &status)) {
42324 0 : tevent_req_received(req);
42325 0 : return status;
42326 : }
42327 :
42328 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
42329 :
42330 0 : tevent_req_received(req);
42331 0 : return NT_STATUS_OK;
42332 : }
42333 :
42334 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct clusapi_AddGroupToGroupSetEx *r)
42335 : {
42336 : NTSTATUS status;
42337 :
42338 0 : status = dcerpc_binding_handle_call(h,
42339 : NULL, &ndr_table_clusapi,
42340 : NDR_CLUSAPI_ADDGROUPTOGROUPSETEX, mem_ctx, r);
42341 :
42342 0 : return status;
42343 : }
42344 :
42345 : struct dcerpc_clusapi_AddGroupToGroupSetEx_state {
42346 : struct clusapi_AddGroupToGroupSetEx orig;
42347 : struct clusapi_AddGroupToGroupSetEx tmp;
42348 : TALLOC_CTX *out_mem_ctx;
42349 : };
42350 :
42351 : static void dcerpc_clusapi_AddGroupToGroupSetEx_done(struct tevent_req *subreq);
42352 :
42353 0 : struct tevent_req *dcerpc_clusapi_AddGroupToGroupSetEx_send(TALLOC_CTX *mem_ctx,
42354 : struct tevent_context *ev,
42355 : struct dcerpc_binding_handle *h,
42356 : struct policy_handle _GroupSet /* [in] */,
42357 : struct policy_handle _Group /* [in] */,
42358 : uint32_t _FaultDomain /* [in] */,
42359 : uint32_t _UpdateDomain /* [in] */,
42360 : uint8_t _UseDomains /* [in] */,
42361 : uint32_t *_Reserved /* [in] [ref] */,
42362 : WERROR *_rpc_status /* [out] [ref] */)
42363 : {
42364 : struct tevent_req *req;
42365 : struct dcerpc_clusapi_AddGroupToGroupSetEx_state *state;
42366 : struct tevent_req *subreq;
42367 :
42368 0 : req = tevent_req_create(mem_ctx, &state,
42369 : struct dcerpc_clusapi_AddGroupToGroupSetEx_state);
42370 0 : if (req == NULL) {
42371 0 : return NULL;
42372 : }
42373 0 : state->out_mem_ctx = NULL;
42374 :
42375 : /* In parameters */
42376 0 : state->orig.in.GroupSet = _GroupSet;
42377 0 : state->orig.in.Group = _Group;
42378 0 : state->orig.in.FaultDomain = _FaultDomain;
42379 0 : state->orig.in.UpdateDomain = _UpdateDomain;
42380 0 : state->orig.in.UseDomains = _UseDomains;
42381 0 : state->orig.in.Reserved = _Reserved;
42382 :
42383 : /* Out parameters */
42384 0 : state->orig.out.rpc_status = _rpc_status;
42385 :
42386 : /* Result */
42387 0 : NDR_ZERO_STRUCT(state->orig.out.result);
42388 :
42389 0 : state->out_mem_ctx = talloc_named_const(state, 0,
42390 : "dcerpc_clusapi_AddGroupToGroupSetEx_out_memory");
42391 0 : if (tevent_req_nomem(state->out_mem_ctx, req)) {
42392 0 : return tevent_req_post(req, ev);
42393 : }
42394 :
42395 : /* make a temporary copy, that we pass to the dispatch function */
42396 0 : state->tmp = state->orig;
42397 :
42398 0 : subreq = dcerpc_clusapi_AddGroupToGroupSetEx_r_send(state, ev, h, &state->tmp);
42399 0 : if (tevent_req_nomem(subreq, req)) {
42400 0 : return tevent_req_post(req, ev);
42401 : }
42402 0 : tevent_req_set_callback(subreq, dcerpc_clusapi_AddGroupToGroupSetEx_done, req);
42403 0 : return req;
42404 : }
42405 :
42406 0 : static void dcerpc_clusapi_AddGroupToGroupSetEx_done(struct tevent_req *subreq)
42407 : {
42408 0 : struct tevent_req *req = tevent_req_callback_data(
42409 : subreq, struct tevent_req);
42410 0 : struct dcerpc_clusapi_AddGroupToGroupSetEx_state *state = tevent_req_data(
42411 : req, struct dcerpc_clusapi_AddGroupToGroupSetEx_state);
42412 : NTSTATUS status;
42413 : TALLOC_CTX *mem_ctx;
42414 :
42415 0 : if (state->out_mem_ctx) {
42416 0 : mem_ctx = state->out_mem_ctx;
42417 : } else {
42418 0 : mem_ctx = state;
42419 : }
42420 :
42421 0 : status = dcerpc_clusapi_AddGroupToGroupSetEx_r_recv(subreq, mem_ctx);
42422 0 : TALLOC_FREE(subreq);
42423 0 : if (tevent_req_nterror(req, status)) {
42424 0 : return;
42425 : }
42426 :
42427 : /* Copy out parameters */
42428 0 : *state->orig.out.rpc_status = *state->tmp.out.rpc_status;
42429 :
42430 : /* Copy result */
42431 0 : state->orig.out.result = state->tmp.out.result;
42432 :
42433 : /* Reset temporary structure */
42434 0 : NDR_ZERO_STRUCT(state->tmp);
42435 :
42436 0 : tevent_req_done(req);
42437 : }
42438 :
42439 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetEx_recv(struct tevent_req *req,
42440 : TALLOC_CTX *mem_ctx,
42441 : WERROR *result)
42442 : {
42443 0 : struct dcerpc_clusapi_AddGroupToGroupSetEx_state *state = tevent_req_data(
42444 : req, struct dcerpc_clusapi_AddGroupToGroupSetEx_state);
42445 : NTSTATUS status;
42446 :
42447 0 : if (tevent_req_is_nterror(req, &status)) {
42448 0 : tevent_req_received(req);
42449 0 : return status;
42450 : }
42451 :
42452 : /* Steal possible out parameters to the callers context */
42453 0 : talloc_steal(mem_ctx, state->out_mem_ctx);
42454 :
42455 : /* Return result */
42456 0 : *result = state->orig.out.result;
42457 :
42458 0 : tevent_req_received(req);
42459 0 : return NT_STATUS_OK;
42460 : }
42461 :
42462 0 : NTSTATUS dcerpc_clusapi_AddGroupToGroupSetEx(struct dcerpc_binding_handle *h,
42463 : TALLOC_CTX *mem_ctx,
42464 : struct policy_handle _GroupSet /* [in] */,
42465 : struct policy_handle _Group /* [in] */,
42466 : uint32_t _FaultDomain /* [in] */,
42467 : uint32_t _UpdateDomain /* [in] */,
42468 : uint8_t _UseDomains /* [in] */,
42469 : uint32_t *_Reserved /* [in] [ref] */,
42470 : WERROR *_rpc_status /* [out] [ref] */,
42471 : WERROR *result)
42472 : {
42473 : struct clusapi_AddGroupToGroupSetEx r;
42474 : NTSTATUS status;
42475 :
42476 : /* In parameters */
42477 0 : r.in.GroupSet = _GroupSet;
42478 0 : r.in.Group = _Group;
42479 0 : r.in.FaultDomain = _FaultDomain;
42480 0 : r.in.UpdateDomain = _UpdateDomain;
42481 0 : r.in.UseDomains = _UseDomains;
42482 0 : r.in.Reserved = _Reserved;
42483 :
42484 : /* Out parameters */
42485 0 : r.out.rpc_status = _rpc_status;
42486 :
42487 : /* Result */
42488 0 : NDR_ZERO_STRUCT(r.out.result);
42489 :
42490 0 : status = dcerpc_clusapi_AddGroupToGroupSetEx_r(h, mem_ctx, &r);
42491 0 : if (!NT_STATUS_IS_OK(status)) {
42492 0 : return status;
42493 : }
42494 :
42495 : /* Return variables */
42496 0 : *_rpc_status = *r.out.rpc_status;
42497 :
42498 : /* Return result */
42499 0 : *result = r.out.result;
42500 :
42501 0 : return NT_STATUS_OK;
42502 : }
42503 :
|
