← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/ndr_eventlog6_c.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/librpc/gen_ndr/ndr_eventlog6_c.c
 
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 "librpc/gen_ndr/ndr_eventlog6.h"
 
7
#include "librpc/gen_ndr/ndr_eventlog6_c.h"
 
8
 
 
9
/* eventlog6 - client functions generated by pidl */
 
10
 
 
11
struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_state {
 
12
        TALLOC_CTX *out_mem_ctx;
 
13
};
 
14
 
 
15
static void dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_done(struct tevent_req *subreq);
 
16
 
 
17
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_send(TALLOC_CTX *mem_ctx,
 
18
        struct tevent_context *ev,
 
19
        struct dcerpc_binding_handle *h,
 
20
        struct eventlog6_EvtRpcRegisterRemoteSubscription *r)
 
21
{
 
22
        struct tevent_req *req;
 
23
        struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_state *state;
 
24
        struct tevent_req *subreq;
 
25
 
 
26
        req = tevent_req_create(mem_ctx, &state,
 
27
                                struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_state);
 
28
        if (req == NULL) {
 
29
                return NULL;
 
30
        }
 
31
 
 
32
        state->out_mem_ctx = talloc_new(state);
 
33
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
34
                return tevent_req_post(req, ev);
 
35
        }
 
36
 
 
37
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
38
                        NULL, &ndr_table_eventlog6,
 
39
                        NDR_EVENTLOG6_EVTRPCREGISTERREMOTESUBSCRIPTION, state->out_mem_ctx, r);
 
40
        if (tevent_req_nomem(subreq, req)) {
 
41
                return tevent_req_post(req, ev);
 
42
        }
 
43
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_done, req);
 
44
 
 
45
        return req;
 
46
}
 
47
 
 
48
static void dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_done(struct tevent_req *subreq)
 
49
{
 
50
        struct tevent_req *req =
 
51
                tevent_req_callback_data(subreq,
 
52
                struct tevent_req);
 
53
        NTSTATUS status;
 
54
 
 
55
        status = dcerpc_binding_handle_call_recv(subreq);
 
56
        if (!NT_STATUS_IS_OK(status)) {
 
57
                tevent_req_nterror(req, status);
 
58
                return;
 
59
        }
 
60
 
 
61
        tevent_req_done(req);
 
62
}
 
63
 
 
64
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
65
{
 
66
        struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_state *state =
 
67
                tevent_req_data(req,
 
68
                struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_state);
 
69
        NTSTATUS status;
 
70
 
 
71
        if (tevent_req_is_nterror(req, &status)) {
 
72
                tevent_req_received(req);
 
73
                return status;
 
74
        }
 
75
 
 
76
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
77
 
 
78
        tevent_req_received(req);
 
79
        return NT_STATUS_OK;
 
80
}
 
81
 
 
82
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRegisterRemoteSubscription *r)
 
83
{
 
84
        NTSTATUS status;
 
85
 
 
86
        status = dcerpc_binding_handle_call(h,
 
87
                        NULL, &ndr_table_eventlog6,
 
88
                        NDR_EVENTLOG6_EVTRPCREGISTERREMOTESUBSCRIPTION, mem_ctx, r);
 
89
 
 
90
        return status;
 
91
}
 
92
 
 
93
struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state {
 
94
        struct eventlog6_EvtRpcRegisterRemoteSubscription orig;
 
95
        struct eventlog6_EvtRpcRegisterRemoteSubscription tmp;
 
96
        TALLOC_CTX *out_mem_ctx;
 
97
};
 
98
 
 
99
static void dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_done(struct tevent_req *subreq);
 
100
 
 
101
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_send(TALLOC_CTX *mem_ctx,
 
102
                                                                          struct tevent_context *ev,
 
103
                                                                          struct dcerpc_binding_handle *h,
 
104
                                                                          const char *_channelPath /* [in] [unique,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
105
                                                                          const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
106
                                                                          const char *_bookmarkXml /* [in] [unique,range(0,MAX_RPC_BOOKMARK_LENGTH),charset(UTF16)] */,
 
107
                                                                          uint32_t _flags /* [in]  */,
 
108
                                                                          struct policy_handle *_handle /* [out] [ref] */,
 
109
                                                                          struct policy_handle *_control /* [out] [ref] */,
 
110
                                                                          uint32_t *_queryChannelInfoSize /* [out] [ref] */,
 
111
                                                                          struct eventlog6_EvtRpcQueryChannelInfo **_queryChannelInfo /* [out] [ref,range(0,MAX_RPC_QUERY_CHANNEL_SIZE),size_is(,*queryChannelInfoSize)] */,
 
112
                                                                          struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
113
{
 
114
        struct tevent_req *req;
 
115
        struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state *state;
 
116
        struct tevent_req *subreq;
 
117
 
 
118
        req = tevent_req_create(mem_ctx, &state,
 
119
                                struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state);
 
120
        if (req == NULL) {
 
121
                return NULL;
 
122
        }
 
123
        state->out_mem_ctx = NULL;
 
124
 
 
125
        /* In parameters */
 
126
        state->orig.in.channelPath = _channelPath;
 
127
        state->orig.in.query = _query;
 
128
        state->orig.in.bookmarkXml = _bookmarkXml;
 
129
        state->orig.in.flags = _flags;
 
130
 
 
131
        /* Out parameters */
 
132
        state->orig.out.handle = _handle;
 
133
        state->orig.out.control = _control;
 
134
        state->orig.out.queryChannelInfoSize = _queryChannelInfoSize;
 
135
        state->orig.out.queryChannelInfo = _queryChannelInfo;
 
136
        state->orig.out.error = _error;
 
137
 
 
138
        /* Result */
 
139
        ZERO_STRUCT(state->orig.out.result);
 
140
 
 
141
        state->out_mem_ctx = talloc_named_const(state, 0,
 
142
                             "dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_out_memory");
 
143
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
144
                return tevent_req_post(req, ev);
 
145
        }
 
146
 
 
147
        /* make a temporary copy, that we pass to the dispatch function */
 
148
        state->tmp = state->orig;
 
149
 
 
150
        subreq = dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_send(state, ev, h, &state->tmp);
 
151
        if (tevent_req_nomem(subreq, req)) {
 
152
                return tevent_req_post(req, ev);
 
153
        }
 
154
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_done, req);
 
155
        return req;
 
156
}
 
157
 
 
158
static void dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_done(struct tevent_req *subreq)
 
159
{
 
160
        struct tevent_req *req = tevent_req_callback_data(
 
161
                subreq, struct tevent_req);
 
162
        struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state *state = tevent_req_data(
 
163
                req, struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state);
 
164
        NTSTATUS status;
 
165
        TALLOC_CTX *mem_ctx;
 
166
 
 
167
        if (state->out_mem_ctx) {
 
168
                mem_ctx = state->out_mem_ctx;
 
169
        } else {
 
170
                mem_ctx = state;
 
171
        }
 
172
 
 
173
        status = dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r_recv(subreq, mem_ctx);
 
174
        TALLOC_FREE(subreq);
 
175
        if (!NT_STATUS_IS_OK(status)) {
 
176
                tevent_req_nterror(req, status);
 
177
                return;
 
178
        }
 
179
 
 
180
        /* Copy out parameters */
 
181
        *state->orig.out.handle = *state->tmp.out.handle;
 
182
        *state->orig.out.control = *state->tmp.out.control;
 
183
        *state->orig.out.queryChannelInfoSize = *state->tmp.out.queryChannelInfoSize;
 
184
        *state->orig.out.queryChannelInfo = *state->tmp.out.queryChannelInfo;
 
185
        *state->orig.out.error = *state->tmp.out.error;
 
186
 
 
187
        /* Copy result */
 
188
        state->orig.out.result = state->tmp.out.result;
 
189
 
 
190
        /* Reset temporary structure */
 
191
        ZERO_STRUCT(state->tmp);
 
192
 
 
193
        tevent_req_done(req);
 
194
}
 
195
 
 
196
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_recv(struct tevent_req *req,
 
197
                                                                TALLOC_CTX *mem_ctx,
 
198
                                                                WERROR *result)
 
199
{
 
200
        struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state *state = tevent_req_data(
 
201
                req, struct dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_state);
 
202
        NTSTATUS status;
 
203
 
 
204
        if (tevent_req_is_nterror(req, &status)) {
 
205
                tevent_req_received(req);
 
206
                return status;
 
207
        }
 
208
 
 
209
        /* Steal possible out parameters to the callers context */
 
210
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
211
 
 
212
        /* Return result */
 
213
        *result = state->orig.out.result;
 
214
 
 
215
        tevent_req_received(req);
 
216
        return NT_STATUS_OK;
 
217
}
 
218
 
 
219
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription(struct dcerpc_binding_handle *h,
 
220
                                                           TALLOC_CTX *mem_ctx,
 
221
                                                           const char *_channelPath /* [in] [unique,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
222
                                                           const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
223
                                                           const char *_bookmarkXml /* [in] [unique,range(0,MAX_RPC_BOOKMARK_LENGTH),charset(UTF16)] */,
 
224
                                                           uint32_t _flags /* [in]  */,
 
225
                                                           struct policy_handle *_handle /* [out] [ref] */,
 
226
                                                           struct policy_handle *_control /* [out] [ref] */,
 
227
                                                           uint32_t *_queryChannelInfoSize /* [out] [ref] */,
 
228
                                                           struct eventlog6_EvtRpcQueryChannelInfo **_queryChannelInfo /* [out] [ref,range(0,MAX_RPC_QUERY_CHANNEL_SIZE),size_is(,*queryChannelInfoSize)] */,
 
229
                                                           struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
230
                                                           WERROR *result)
 
231
{
 
232
        struct eventlog6_EvtRpcRegisterRemoteSubscription r;
 
233
        NTSTATUS status;
 
234
 
 
235
        /* In parameters */
 
236
        r.in.channelPath = _channelPath;
 
237
        r.in.query = _query;
 
238
        r.in.bookmarkXml = _bookmarkXml;
 
239
        r.in.flags = _flags;
 
240
 
 
241
        status = dcerpc_eventlog6_EvtRpcRegisterRemoteSubscription_r(h, mem_ctx, &r);
 
242
        if (!NT_STATUS_IS_OK(status)) {
 
243
                return status;
 
244
        }
 
245
 
 
246
        /* Return variables */
 
247
        *_handle = *r.out.handle;
 
248
        *_control = *r.out.control;
 
249
        *_queryChannelInfoSize = *r.out.queryChannelInfoSize;
 
250
        *_queryChannelInfo = *r.out.queryChannelInfo;
 
251
        *_error = *r.out.error;
 
252
 
 
253
        /* Return result */
 
254
        *result = r.out.result;
 
255
 
 
256
        return NT_STATUS_OK;
 
257
}
 
258
 
 
259
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_state {
 
260
        TALLOC_CTX *out_mem_ctx;
 
261
};
 
262
 
 
263
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_done(struct tevent_req *subreq);
 
264
 
 
265
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_send(TALLOC_CTX *mem_ctx,
 
266
        struct tevent_context *ev,
 
267
        struct dcerpc_binding_handle *h,
 
268
        struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r)
 
269
{
 
270
        struct tevent_req *req;
 
271
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_state *state;
 
272
        struct tevent_req *subreq;
 
273
 
 
274
        req = tevent_req_create(mem_ctx, &state,
 
275
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_state);
 
276
        if (req == NULL) {
 
277
                return NULL;
 
278
        }
 
279
 
 
280
        state->out_mem_ctx = talloc_new(state);
 
281
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
282
                return tevent_req_post(req, ev);
 
283
        }
 
284
 
 
285
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
286
                        NULL, &ndr_table_eventlog6,
 
287
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONNEXTASYNC, state->out_mem_ctx, r);
 
288
        if (tevent_req_nomem(subreq, req)) {
 
289
                return tevent_req_post(req, ev);
 
290
        }
 
291
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_done, req);
 
292
 
 
293
        return req;
 
294
}
 
295
 
 
296
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_done(struct tevent_req *subreq)
 
297
{
 
298
        struct tevent_req *req =
 
299
                tevent_req_callback_data(subreq,
 
300
                struct tevent_req);
 
301
        NTSTATUS status;
 
302
 
 
303
        status = dcerpc_binding_handle_call_recv(subreq);
 
304
        if (!NT_STATUS_IS_OK(status)) {
 
305
                tevent_req_nterror(req, status);
 
306
                return;
 
307
        }
 
308
 
 
309
        tevent_req_done(req);
 
310
}
 
311
 
 
312
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
313
{
 
314
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_state *state =
 
315
                tevent_req_data(req,
 
316
                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_state);
 
317
        NTSTATUS status;
 
318
 
 
319
        if (tevent_req_is_nterror(req, &status)) {
 
320
                tevent_req_received(req);
 
321
                return status;
 
322
        }
 
323
 
 
324
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
325
 
 
326
        tevent_req_received(req);
 
327
        return NT_STATUS_OK;
 
328
}
 
329
 
 
330
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r)
 
331
{
 
332
        NTSTATUS status;
 
333
 
 
334
        status = dcerpc_binding_handle_call(h,
 
335
                        NULL, &ndr_table_eventlog6,
 
336
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONNEXTASYNC, mem_ctx, r);
 
337
 
 
338
        return status;
 
339
}
 
340
 
 
341
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state {
 
342
        struct eventlog6_EvtRpcRemoteSubscriptionNextAsync orig;
 
343
        struct eventlog6_EvtRpcRemoteSubscriptionNextAsync tmp;
 
344
        TALLOC_CTX *out_mem_ctx;
 
345
};
 
346
 
 
347
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_done(struct tevent_req *subreq);
 
348
 
 
349
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_send(TALLOC_CTX *mem_ctx,
 
350
                                                                           struct tevent_context *ev,
 
351
                                                                           struct dcerpc_binding_handle *h,
 
352
                                                                           struct policy_handle *_handle /* [in] [ref] */,
 
353
                                                                           uint32_t _numRequestedRecords /* [in]  */,
 
354
                                                                           uint32_t _flags /* [in]  */,
 
355
                                                                           uint32_t *_numActualRecords /* [out] [ref] */,
 
356
                                                                           uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
357
                                                                           uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
358
                                                                           uint32_t *_resultBufferSize /* [out] [ref] */,
 
359
                                                                           uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */)
 
360
{
 
361
        struct tevent_req *req;
 
362
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state *state;
 
363
        struct tevent_req *subreq;
 
364
 
 
365
        req = tevent_req_create(mem_ctx, &state,
 
366
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state);
 
367
        if (req == NULL) {
 
368
                return NULL;
 
369
        }
 
370
        state->out_mem_ctx = NULL;
 
371
 
 
372
        /* In parameters */
 
373
        state->orig.in.handle = _handle;
 
374
        state->orig.in.numRequestedRecords = _numRequestedRecords;
 
375
        state->orig.in.flags = _flags;
 
376
 
 
377
        /* Out parameters */
 
378
        state->orig.out.numActualRecords = _numActualRecords;
 
379
        state->orig.out.eventDataIndices = _eventDataIndices;
 
380
        state->orig.out.eventDataSizes = _eventDataSizes;
 
381
        state->orig.out.resultBufferSize = _resultBufferSize;
 
382
        state->orig.out.resultBuffer = _resultBuffer;
 
383
 
 
384
        /* Result */
 
385
        ZERO_STRUCT(state->orig.out.result);
 
386
 
 
387
        state->out_mem_ctx = talloc_named_const(state, 0,
 
388
                             "dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_out_memory");
 
389
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
390
                return tevent_req_post(req, ev);
 
391
        }
 
392
 
 
393
        /* make a temporary copy, that we pass to the dispatch function */
 
394
        state->tmp = state->orig;
 
395
 
 
396
        subreq = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_send(state, ev, h, &state->tmp);
 
397
        if (tevent_req_nomem(subreq, req)) {
 
398
                return tevent_req_post(req, ev);
 
399
        }
 
400
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_done, req);
 
401
        return req;
 
402
}
 
403
 
 
404
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_done(struct tevent_req *subreq)
 
405
{
 
406
        struct tevent_req *req = tevent_req_callback_data(
 
407
                subreq, struct tevent_req);
 
408
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state *state = tevent_req_data(
 
409
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state);
 
410
        NTSTATUS status;
 
411
        TALLOC_CTX *mem_ctx;
 
412
 
 
413
        if (state->out_mem_ctx) {
 
414
                mem_ctx = state->out_mem_ctx;
 
415
        } else {
 
416
                mem_ctx = state;
 
417
        }
 
418
 
 
419
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r_recv(subreq, mem_ctx);
 
420
        TALLOC_FREE(subreq);
 
421
        if (!NT_STATUS_IS_OK(status)) {
 
422
                tevent_req_nterror(req, status);
 
423
                return;
 
424
        }
 
425
 
 
426
        /* Copy out parameters */
 
427
        *state->orig.out.numActualRecords = *state->tmp.out.numActualRecords;
 
428
        *state->orig.out.eventDataIndices = *state->tmp.out.eventDataIndices;
 
429
        *state->orig.out.eventDataSizes = *state->tmp.out.eventDataSizes;
 
430
        *state->orig.out.resultBufferSize = *state->tmp.out.resultBufferSize;
 
431
        *state->orig.out.resultBuffer = *state->tmp.out.resultBuffer;
 
432
 
 
433
        /* Copy result */
 
434
        state->orig.out.result = state->tmp.out.result;
 
435
 
 
436
        /* Reset temporary structure */
 
437
        ZERO_STRUCT(state->tmp);
 
438
 
 
439
        tevent_req_done(req);
 
440
}
 
441
 
 
442
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_recv(struct tevent_req *req,
 
443
                                                                 TALLOC_CTX *mem_ctx,
 
444
                                                                 WERROR *result)
 
445
{
 
446
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state *state = tevent_req_data(
 
447
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_state);
 
448
        NTSTATUS status;
 
449
 
 
450
        if (tevent_req_is_nterror(req, &status)) {
 
451
                tevent_req_received(req);
 
452
                return status;
 
453
        }
 
454
 
 
455
        /* Steal possible out parameters to the callers context */
 
456
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
457
 
 
458
        /* Return result */
 
459
        *result = state->orig.out.result;
 
460
 
 
461
        tevent_req_received(req);
 
462
        return NT_STATUS_OK;
 
463
}
 
464
 
 
465
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync(struct dcerpc_binding_handle *h,
 
466
                                                            TALLOC_CTX *mem_ctx,
 
467
                                                            struct policy_handle *_handle /* [in] [ref] */,
 
468
                                                            uint32_t _numRequestedRecords /* [in]  */,
 
469
                                                            uint32_t _flags /* [in]  */,
 
470
                                                            uint32_t *_numActualRecords /* [out] [ref] */,
 
471
                                                            uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
472
                                                            uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
473
                                                            uint32_t *_resultBufferSize /* [out] [ref] */,
 
474
                                                            uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */,
 
475
                                                            WERROR *result)
 
476
{
 
477
        struct eventlog6_EvtRpcRemoteSubscriptionNextAsync r;
 
478
        NTSTATUS status;
 
479
 
 
480
        /* In parameters */
 
481
        r.in.handle = _handle;
 
482
        r.in.numRequestedRecords = _numRequestedRecords;
 
483
        r.in.flags = _flags;
 
484
 
 
485
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNextAsync_r(h, mem_ctx, &r);
 
486
        if (!NT_STATUS_IS_OK(status)) {
 
487
                return status;
 
488
        }
 
489
 
 
490
        /* Return variables */
 
491
        *_numActualRecords = *r.out.numActualRecords;
 
492
        *_eventDataIndices = *r.out.eventDataIndices;
 
493
        *_eventDataSizes = *r.out.eventDataSizes;
 
494
        *_resultBufferSize = *r.out.resultBufferSize;
 
495
        *_resultBuffer = *r.out.resultBuffer;
 
496
 
 
497
        /* Return result */
 
498
        *result = r.out.result;
 
499
 
 
500
        return NT_STATUS_OK;
 
501
}
 
502
 
 
503
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_state {
 
504
        TALLOC_CTX *out_mem_ctx;
 
505
};
 
506
 
 
507
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_done(struct tevent_req *subreq);
 
508
 
 
509
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_send(TALLOC_CTX *mem_ctx,
 
510
        struct tevent_context *ev,
 
511
        struct dcerpc_binding_handle *h,
 
512
        struct eventlog6_EvtRpcRemoteSubscriptionNext *r)
 
513
{
 
514
        struct tevent_req *req;
 
515
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_state *state;
 
516
        struct tevent_req *subreq;
 
517
 
 
518
        req = tevent_req_create(mem_ctx, &state,
 
519
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_state);
 
520
        if (req == NULL) {
 
521
                return NULL;
 
522
        }
 
523
 
 
524
        state->out_mem_ctx = talloc_new(state);
 
525
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
526
                return tevent_req_post(req, ev);
 
527
        }
 
528
 
 
529
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
530
                        NULL, &ndr_table_eventlog6,
 
531
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONNEXT, state->out_mem_ctx, r);
 
532
        if (tevent_req_nomem(subreq, req)) {
 
533
                return tevent_req_post(req, ev);
 
534
        }
 
535
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_done, req);
 
536
 
 
537
        return req;
 
538
}
 
539
 
 
540
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_done(struct tevent_req *subreq)
 
541
{
 
542
        struct tevent_req *req =
 
543
                tevent_req_callback_data(subreq,
 
544
                struct tevent_req);
 
545
        NTSTATUS status;
 
546
 
 
547
        status = dcerpc_binding_handle_call_recv(subreq);
 
548
        if (!NT_STATUS_IS_OK(status)) {
 
549
                tevent_req_nterror(req, status);
 
550
                return;
 
551
        }
 
552
 
 
553
        tevent_req_done(req);
 
554
}
 
555
 
 
556
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
557
{
 
558
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_state *state =
 
559
                tevent_req_data(req,
 
560
                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_state);
 
561
        NTSTATUS status;
 
562
 
 
563
        if (tevent_req_is_nterror(req, &status)) {
 
564
                tevent_req_received(req);
 
565
                return status;
 
566
        }
 
567
 
 
568
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
569
 
 
570
        tevent_req_received(req);
 
571
        return NT_STATUS_OK;
 
572
}
 
573
 
 
574
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRemoteSubscriptionNext *r)
 
575
{
 
576
        NTSTATUS status;
 
577
 
 
578
        status = dcerpc_binding_handle_call(h,
 
579
                        NULL, &ndr_table_eventlog6,
 
580
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONNEXT, mem_ctx, r);
 
581
 
 
582
        return status;
 
583
}
 
584
 
 
585
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state {
 
586
        struct eventlog6_EvtRpcRemoteSubscriptionNext orig;
 
587
        struct eventlog6_EvtRpcRemoteSubscriptionNext tmp;
 
588
        TALLOC_CTX *out_mem_ctx;
 
589
};
 
590
 
 
591
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_done(struct tevent_req *subreq);
 
592
 
 
593
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_send(TALLOC_CTX *mem_ctx,
 
594
                                                                      struct tevent_context *ev,
 
595
                                                                      struct dcerpc_binding_handle *h,
 
596
                                                                      struct policy_handle *_handle /* [in] [ref] */,
 
597
                                                                      uint32_t _numRequestedRecords /* [in]  */,
 
598
                                                                      uint32_t _timeOut /* [in]  */,
 
599
                                                                      uint32_t _flags /* [in]  */,
 
600
                                                                      uint32_t *_numActualRecords /* [out] [ref] */,
 
601
                                                                      uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
602
                                                                      uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
603
                                                                      uint32_t *_resultBufferSize /* [out] [ref] */,
 
604
                                                                      uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */)
 
605
{
 
606
        struct tevent_req *req;
 
607
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state *state;
 
608
        struct tevent_req *subreq;
 
609
 
 
610
        req = tevent_req_create(mem_ctx, &state,
 
611
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state);
 
612
        if (req == NULL) {
 
613
                return NULL;
 
614
        }
 
615
        state->out_mem_ctx = NULL;
 
616
 
 
617
        /* In parameters */
 
618
        state->orig.in.handle = _handle;
 
619
        state->orig.in.numRequestedRecords = _numRequestedRecords;
 
620
        state->orig.in.timeOut = _timeOut;
 
621
        state->orig.in.flags = _flags;
 
622
 
 
623
        /* Out parameters */
 
624
        state->orig.out.numActualRecords = _numActualRecords;
 
625
        state->orig.out.eventDataIndices = _eventDataIndices;
 
626
        state->orig.out.eventDataSizes = _eventDataSizes;
 
627
        state->orig.out.resultBufferSize = _resultBufferSize;
 
628
        state->orig.out.resultBuffer = _resultBuffer;
 
629
 
 
630
        /* Result */
 
631
        ZERO_STRUCT(state->orig.out.result);
 
632
 
 
633
        state->out_mem_ctx = talloc_named_const(state, 0,
 
634
                             "dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_out_memory");
 
635
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
636
                return tevent_req_post(req, ev);
 
637
        }
 
638
 
 
639
        /* make a temporary copy, that we pass to the dispatch function */
 
640
        state->tmp = state->orig;
 
641
 
 
642
        subreq = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_send(state, ev, h, &state->tmp);
 
643
        if (tevent_req_nomem(subreq, req)) {
 
644
                return tevent_req_post(req, ev);
 
645
        }
 
646
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_done, req);
 
647
        return req;
 
648
}
 
649
 
 
650
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_done(struct tevent_req *subreq)
 
651
{
 
652
        struct tevent_req *req = tevent_req_callback_data(
 
653
                subreq, struct tevent_req);
 
654
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state *state = tevent_req_data(
 
655
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state);
 
656
        NTSTATUS status;
 
657
        TALLOC_CTX *mem_ctx;
 
658
 
 
659
        if (state->out_mem_ctx) {
 
660
                mem_ctx = state->out_mem_ctx;
 
661
        } else {
 
662
                mem_ctx = state;
 
663
        }
 
664
 
 
665
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r_recv(subreq, mem_ctx);
 
666
        TALLOC_FREE(subreq);
 
667
        if (!NT_STATUS_IS_OK(status)) {
 
668
                tevent_req_nterror(req, status);
 
669
                return;
 
670
        }
 
671
 
 
672
        /* Copy out parameters */
 
673
        *state->orig.out.numActualRecords = *state->tmp.out.numActualRecords;
 
674
        *state->orig.out.eventDataIndices = *state->tmp.out.eventDataIndices;
 
675
        *state->orig.out.eventDataSizes = *state->tmp.out.eventDataSizes;
 
676
        *state->orig.out.resultBufferSize = *state->tmp.out.resultBufferSize;
 
677
        *state->orig.out.resultBuffer = *state->tmp.out.resultBuffer;
 
678
 
 
679
        /* Copy result */
 
680
        state->orig.out.result = state->tmp.out.result;
 
681
 
 
682
        /* Reset temporary structure */
 
683
        ZERO_STRUCT(state->tmp);
 
684
 
 
685
        tevent_req_done(req);
 
686
}
 
687
 
 
688
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_recv(struct tevent_req *req,
 
689
                                                            TALLOC_CTX *mem_ctx,
 
690
                                                            WERROR *result)
 
691
{
 
692
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state *state = tevent_req_data(
 
693
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_state);
 
694
        NTSTATUS status;
 
695
 
 
696
        if (tevent_req_is_nterror(req, &status)) {
 
697
                tevent_req_received(req);
 
698
                return status;
 
699
        }
 
700
 
 
701
        /* Steal possible out parameters to the callers context */
 
702
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
703
 
 
704
        /* Return result */
 
705
        *result = state->orig.out.result;
 
706
 
 
707
        tevent_req_received(req);
 
708
        return NT_STATUS_OK;
 
709
}
 
710
 
 
711
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext(struct dcerpc_binding_handle *h,
 
712
                                                       TALLOC_CTX *mem_ctx,
 
713
                                                       struct policy_handle *_handle /* [in] [ref] */,
 
714
                                                       uint32_t _numRequestedRecords /* [in]  */,
 
715
                                                       uint32_t _timeOut /* [in]  */,
 
716
                                                       uint32_t _flags /* [in]  */,
 
717
                                                       uint32_t *_numActualRecords /* [out] [ref] */,
 
718
                                                       uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
719
                                                       uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
720
                                                       uint32_t *_resultBufferSize /* [out] [ref] */,
 
721
                                                       uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */,
 
722
                                                       WERROR *result)
 
723
{
 
724
        struct eventlog6_EvtRpcRemoteSubscriptionNext r;
 
725
        NTSTATUS status;
 
726
 
 
727
        /* In parameters */
 
728
        r.in.handle = _handle;
 
729
        r.in.numRequestedRecords = _numRequestedRecords;
 
730
        r.in.timeOut = _timeOut;
 
731
        r.in.flags = _flags;
 
732
 
 
733
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionNext_r(h, mem_ctx, &r);
 
734
        if (!NT_STATUS_IS_OK(status)) {
 
735
                return status;
 
736
        }
 
737
 
 
738
        /* Return variables */
 
739
        *_numActualRecords = *r.out.numActualRecords;
 
740
        *_eventDataIndices = *r.out.eventDataIndices;
 
741
        *_eventDataSizes = *r.out.eventDataSizes;
 
742
        *_resultBufferSize = *r.out.resultBufferSize;
 
743
        *_resultBuffer = *r.out.resultBuffer;
 
744
 
 
745
        /* Return result */
 
746
        *result = r.out.result;
 
747
 
 
748
        return NT_STATUS_OK;
 
749
}
 
750
 
 
751
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_state {
 
752
        TALLOC_CTX *out_mem_ctx;
 
753
};
 
754
 
 
755
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_done(struct tevent_req *subreq);
 
756
 
 
757
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_send(TALLOC_CTX *mem_ctx,
 
758
        struct tevent_context *ev,
 
759
        struct dcerpc_binding_handle *h,
 
760
        struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r)
 
761
{
 
762
        struct tevent_req *req;
 
763
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_state *state;
 
764
        struct tevent_req *subreq;
 
765
 
 
766
        req = tevent_req_create(mem_ctx, &state,
 
767
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_state);
 
768
        if (req == NULL) {
 
769
                return NULL;
 
770
        }
 
771
 
 
772
        state->out_mem_ctx = NULL;
 
773
 
 
774
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
775
                        NULL, &ndr_table_eventlog6,
 
776
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONWAITASYNC, state, r);
 
777
        if (tevent_req_nomem(subreq, req)) {
 
778
                return tevent_req_post(req, ev);
 
779
        }
 
780
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_done, req);
 
781
 
 
782
        return req;
 
783
}
 
784
 
 
785
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_done(struct tevent_req *subreq)
 
786
{
 
787
        struct tevent_req *req =
 
788
                tevent_req_callback_data(subreq,
 
789
                struct tevent_req);
 
790
        NTSTATUS status;
 
791
 
 
792
        status = dcerpc_binding_handle_call_recv(subreq);
 
793
        if (!NT_STATUS_IS_OK(status)) {
 
794
                tevent_req_nterror(req, status);
 
795
                return;
 
796
        }
 
797
 
 
798
        tevent_req_done(req);
 
799
}
 
800
 
 
801
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
802
{
 
803
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_state *state =
 
804
                tevent_req_data(req,
 
805
                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_state);
 
806
        NTSTATUS status;
 
807
 
 
808
        if (tevent_req_is_nterror(req, &status)) {
 
809
                tevent_req_received(req);
 
810
                return status;
 
811
        }
 
812
 
 
813
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
814
 
 
815
        tevent_req_received(req);
 
816
        return NT_STATUS_OK;
 
817
}
 
818
 
 
819
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r)
 
820
{
 
821
        NTSTATUS status;
 
822
 
 
823
        status = dcerpc_binding_handle_call(h,
 
824
                        NULL, &ndr_table_eventlog6,
 
825
                        NDR_EVENTLOG6_EVTRPCREMOTESUBSCRIPTIONWAITASYNC, mem_ctx, r);
 
826
 
 
827
        return status;
 
828
}
 
829
 
 
830
struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state {
 
831
        struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync orig;
 
832
        struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync tmp;
 
833
        TALLOC_CTX *out_mem_ctx;
 
834
};
 
835
 
 
836
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_done(struct tevent_req *subreq);
 
837
 
 
838
struct tevent_req *dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_send(TALLOC_CTX *mem_ctx,
 
839
                                                                           struct tevent_context *ev,
 
840
                                                                           struct dcerpc_binding_handle *h,
 
841
                                                                           struct policy_handle *_handle /* [in] [ref] */)
 
842
{
 
843
        struct tevent_req *req;
 
844
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state *state;
 
845
        struct tevent_req *subreq;
 
846
 
 
847
        req = tevent_req_create(mem_ctx, &state,
 
848
                                struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state);
 
849
        if (req == NULL) {
 
850
                return NULL;
 
851
        }
 
852
        state->out_mem_ctx = NULL;
 
853
 
 
854
        /* In parameters */
 
855
        state->orig.in.handle = _handle;
 
856
 
 
857
        /* Out parameters */
 
858
 
 
859
        /* Result */
 
860
        ZERO_STRUCT(state->orig.out.result);
 
861
 
 
862
        /* make a temporary copy, that we pass to the dispatch function */
 
863
        state->tmp = state->orig;
 
864
 
 
865
        subreq = dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_send(state, ev, h, &state->tmp);
 
866
        if (tevent_req_nomem(subreq, req)) {
 
867
                return tevent_req_post(req, ev);
 
868
        }
 
869
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_done, req);
 
870
        return req;
 
871
}
 
872
 
 
873
static void dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_done(struct tevent_req *subreq)
 
874
{
 
875
        struct tevent_req *req = tevent_req_callback_data(
 
876
                subreq, struct tevent_req);
 
877
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state *state = tevent_req_data(
 
878
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state);
 
879
        NTSTATUS status;
 
880
        TALLOC_CTX *mem_ctx;
 
881
 
 
882
        if (state->out_mem_ctx) {
 
883
                mem_ctx = state->out_mem_ctx;
 
884
        } else {
 
885
                mem_ctx = state;
 
886
        }
 
887
 
 
888
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r_recv(subreq, mem_ctx);
 
889
        TALLOC_FREE(subreq);
 
890
        if (!NT_STATUS_IS_OK(status)) {
 
891
                tevent_req_nterror(req, status);
 
892
                return;
 
893
        }
 
894
 
 
895
        /* Copy out parameters */
 
896
 
 
897
        /* Copy result */
 
898
        state->orig.out.result = state->tmp.out.result;
 
899
 
 
900
        /* Reset temporary structure */
 
901
        ZERO_STRUCT(state->tmp);
 
902
 
 
903
        tevent_req_done(req);
 
904
}
 
905
 
 
906
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_recv(struct tevent_req *req,
 
907
                                                                 TALLOC_CTX *mem_ctx,
 
908
                                                                 WERROR *result)
 
909
{
 
910
        struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state *state = tevent_req_data(
 
911
                req, struct dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_state);
 
912
        NTSTATUS status;
 
913
 
 
914
        if (tevent_req_is_nterror(req, &status)) {
 
915
                tevent_req_received(req);
 
916
                return status;
 
917
        }
 
918
 
 
919
        /* Steal possible out parameters to the callers context */
 
920
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
921
 
 
922
        /* Return result */
 
923
        *result = state->orig.out.result;
 
924
 
 
925
        tevent_req_received(req);
 
926
        return NT_STATUS_OK;
 
927
}
 
928
 
 
929
NTSTATUS dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync(struct dcerpc_binding_handle *h,
 
930
                                                            TALLOC_CTX *mem_ctx,
 
931
                                                            struct policy_handle *_handle /* [in] [ref] */,
 
932
                                                            WERROR *result)
 
933
{
 
934
        struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync r;
 
935
        NTSTATUS status;
 
936
 
 
937
        /* In parameters */
 
938
        r.in.handle = _handle;
 
939
 
 
940
        status = dcerpc_eventlog6_EvtRpcRemoteSubscriptionWaitAsync_r(h, mem_ctx, &r);
 
941
        if (!NT_STATUS_IS_OK(status)) {
 
942
                return status;
 
943
        }
 
944
 
 
945
        /* Return variables */
 
946
 
 
947
        /* Return result */
 
948
        *result = r.out.result;
 
949
 
 
950
        return NT_STATUS_OK;
 
951
}
 
952
 
 
953
struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_state {
 
954
        TALLOC_CTX *out_mem_ctx;
 
955
};
 
956
 
 
957
static void dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_done(struct tevent_req *subreq);
 
958
 
 
959
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_send(TALLOC_CTX *mem_ctx,
 
960
        struct tevent_context *ev,
 
961
        struct dcerpc_binding_handle *h,
 
962
        struct eventlog6_EvtRpcRegisterControllableOperation *r)
 
963
{
 
964
        struct tevent_req *req;
 
965
        struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_state *state;
 
966
        struct tevent_req *subreq;
 
967
 
 
968
        req = tevent_req_create(mem_ctx, &state,
 
969
                                struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_state);
 
970
        if (req == NULL) {
 
971
                return NULL;
 
972
        }
 
973
 
 
974
        state->out_mem_ctx = talloc_new(state);
 
975
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
976
                return tevent_req_post(req, ev);
 
977
        }
 
978
 
 
979
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
980
                        NULL, &ndr_table_eventlog6,
 
981
                        NDR_EVENTLOG6_EVTRPCREGISTERCONTROLLABLEOPERATION, state->out_mem_ctx, r);
 
982
        if (tevent_req_nomem(subreq, req)) {
 
983
                return tevent_req_post(req, ev);
 
984
        }
 
985
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_done, req);
 
986
 
 
987
        return req;
 
988
}
 
989
 
 
990
static void dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_done(struct tevent_req *subreq)
 
991
{
 
992
        struct tevent_req *req =
 
993
                tevent_req_callback_data(subreq,
 
994
                struct tevent_req);
 
995
        NTSTATUS status;
 
996
 
 
997
        status = dcerpc_binding_handle_call_recv(subreq);
 
998
        if (!NT_STATUS_IS_OK(status)) {
 
999
                tevent_req_nterror(req, status);
 
1000
                return;
 
1001
        }
 
1002
 
 
1003
        tevent_req_done(req);
 
1004
}
 
1005
 
 
1006
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1007
{
 
1008
        struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_state *state =
 
1009
                tevent_req_data(req,
 
1010
                struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_state);
 
1011
        NTSTATUS status;
 
1012
 
 
1013
        if (tevent_req_is_nterror(req, &status)) {
 
1014
                tevent_req_received(req);
 
1015
                return status;
 
1016
        }
 
1017
 
 
1018
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1019
 
 
1020
        tevent_req_received(req);
 
1021
        return NT_STATUS_OK;
 
1022
}
 
1023
 
 
1024
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRegisterControllableOperation *r)
 
1025
{
 
1026
        NTSTATUS status;
 
1027
 
 
1028
        status = dcerpc_binding_handle_call(h,
 
1029
                        NULL, &ndr_table_eventlog6,
 
1030
                        NDR_EVENTLOG6_EVTRPCREGISTERCONTROLLABLEOPERATION, mem_ctx, r);
 
1031
 
 
1032
        return status;
 
1033
}
 
1034
 
 
1035
struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state {
 
1036
        struct eventlog6_EvtRpcRegisterControllableOperation orig;
 
1037
        struct eventlog6_EvtRpcRegisterControllableOperation tmp;
 
1038
        TALLOC_CTX *out_mem_ctx;
 
1039
};
 
1040
 
 
1041
static void dcerpc_eventlog6_EvtRpcRegisterControllableOperation_done(struct tevent_req *subreq);
 
1042
 
 
1043
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterControllableOperation_send(TALLOC_CTX *mem_ctx,
 
1044
                                                                             struct tevent_context *ev,
 
1045
                                                                             struct dcerpc_binding_handle *h,
 
1046
                                                                             struct policy_handle *_handle /* [out] [ref] */)
 
1047
{
 
1048
        struct tevent_req *req;
 
1049
        struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state *state;
 
1050
        struct tevent_req *subreq;
 
1051
 
 
1052
        req = tevent_req_create(mem_ctx, &state,
 
1053
                                struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state);
 
1054
        if (req == NULL) {
 
1055
                return NULL;
 
1056
        }
 
1057
        state->out_mem_ctx = NULL;
 
1058
 
 
1059
        /* In parameters */
 
1060
 
 
1061
        /* Out parameters */
 
1062
        state->orig.out.handle = _handle;
 
1063
 
 
1064
        /* Result */
 
1065
        ZERO_STRUCT(state->orig.out.result);
 
1066
 
 
1067
        state->out_mem_ctx = talloc_named_const(state, 0,
 
1068
                             "dcerpc_eventlog6_EvtRpcRegisterControllableOperation_out_memory");
 
1069
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1070
                return tevent_req_post(req, ev);
 
1071
        }
 
1072
 
 
1073
        /* make a temporary copy, that we pass to the dispatch function */
 
1074
        state->tmp = state->orig;
 
1075
 
 
1076
        subreq = dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_send(state, ev, h, &state->tmp);
 
1077
        if (tevent_req_nomem(subreq, req)) {
 
1078
                return tevent_req_post(req, ev);
 
1079
        }
 
1080
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterControllableOperation_done, req);
 
1081
        return req;
 
1082
}
 
1083
 
 
1084
static void dcerpc_eventlog6_EvtRpcRegisterControllableOperation_done(struct tevent_req *subreq)
 
1085
{
 
1086
        struct tevent_req *req = tevent_req_callback_data(
 
1087
                subreq, struct tevent_req);
 
1088
        struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state *state = tevent_req_data(
 
1089
                req, struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state);
 
1090
        NTSTATUS status;
 
1091
        TALLOC_CTX *mem_ctx;
 
1092
 
 
1093
        if (state->out_mem_ctx) {
 
1094
                mem_ctx = state->out_mem_ctx;
 
1095
        } else {
 
1096
                mem_ctx = state;
 
1097
        }
 
1098
 
 
1099
        status = dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r_recv(subreq, mem_ctx);
 
1100
        TALLOC_FREE(subreq);
 
1101
        if (!NT_STATUS_IS_OK(status)) {
 
1102
                tevent_req_nterror(req, status);
 
1103
                return;
 
1104
        }
 
1105
 
 
1106
        /* Copy out parameters */
 
1107
        *state->orig.out.handle = *state->tmp.out.handle;
 
1108
 
 
1109
        /* Copy result */
 
1110
        state->orig.out.result = state->tmp.out.result;
 
1111
 
 
1112
        /* Reset temporary structure */
 
1113
        ZERO_STRUCT(state->tmp);
 
1114
 
 
1115
        tevent_req_done(req);
 
1116
}
 
1117
 
 
1118
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterControllableOperation_recv(struct tevent_req *req,
 
1119
                                                                   TALLOC_CTX *mem_ctx,
 
1120
                                                                   WERROR *result)
 
1121
{
 
1122
        struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state *state = tevent_req_data(
 
1123
                req, struct dcerpc_eventlog6_EvtRpcRegisterControllableOperation_state);
 
1124
        NTSTATUS status;
 
1125
 
 
1126
        if (tevent_req_is_nterror(req, &status)) {
 
1127
                tevent_req_received(req);
 
1128
                return status;
 
1129
        }
 
1130
 
 
1131
        /* Steal possible out parameters to the callers context */
 
1132
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1133
 
 
1134
        /* Return result */
 
1135
        *result = state->orig.out.result;
 
1136
 
 
1137
        tevent_req_received(req);
 
1138
        return NT_STATUS_OK;
 
1139
}
 
1140
 
 
1141
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterControllableOperation(struct dcerpc_binding_handle *h,
 
1142
                                                              TALLOC_CTX *mem_ctx,
 
1143
                                                              struct policy_handle *_handle /* [out] [ref] */,
 
1144
                                                              WERROR *result)
 
1145
{
 
1146
        struct eventlog6_EvtRpcRegisterControllableOperation r;
 
1147
        NTSTATUS status;
 
1148
 
 
1149
        /* In parameters */
 
1150
 
 
1151
        status = dcerpc_eventlog6_EvtRpcRegisterControllableOperation_r(h, mem_ctx, &r);
 
1152
        if (!NT_STATUS_IS_OK(status)) {
 
1153
                return status;
 
1154
        }
 
1155
 
 
1156
        /* Return variables */
 
1157
        *_handle = *r.out.handle;
 
1158
 
 
1159
        /* Return result */
 
1160
        *result = r.out.result;
 
1161
 
 
1162
        return NT_STATUS_OK;
 
1163
}
 
1164
 
 
1165
struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_state {
 
1166
        TALLOC_CTX *out_mem_ctx;
 
1167
};
 
1168
 
 
1169
static void dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_done(struct tevent_req *subreq);
 
1170
 
 
1171
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_send(TALLOC_CTX *mem_ctx,
 
1172
        struct tevent_context *ev,
 
1173
        struct dcerpc_binding_handle *h,
 
1174
        struct eventlog6_EvtRpcRegisterLogQuery *r)
 
1175
{
 
1176
        struct tevent_req *req;
 
1177
        struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_state *state;
 
1178
        struct tevent_req *subreq;
 
1179
 
 
1180
        req = tevent_req_create(mem_ctx, &state,
 
1181
                                struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_state);
 
1182
        if (req == NULL) {
 
1183
                return NULL;
 
1184
        }
 
1185
 
 
1186
        state->out_mem_ctx = talloc_new(state);
 
1187
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1188
                return tevent_req_post(req, ev);
 
1189
        }
 
1190
 
 
1191
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1192
                        NULL, &ndr_table_eventlog6,
 
1193
                        NDR_EVENTLOG6_EVTRPCREGISTERLOGQUERY, state->out_mem_ctx, r);
 
1194
        if (tevent_req_nomem(subreq, req)) {
 
1195
                return tevent_req_post(req, ev);
 
1196
        }
 
1197
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_done, req);
 
1198
 
 
1199
        return req;
 
1200
}
 
1201
 
 
1202
static void dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_done(struct tevent_req *subreq)
 
1203
{
 
1204
        struct tevent_req *req =
 
1205
                tevent_req_callback_data(subreq,
 
1206
                struct tevent_req);
 
1207
        NTSTATUS status;
 
1208
 
 
1209
        status = dcerpc_binding_handle_call_recv(subreq);
 
1210
        if (!NT_STATUS_IS_OK(status)) {
 
1211
                tevent_req_nterror(req, status);
 
1212
                return;
 
1213
        }
 
1214
 
 
1215
        tevent_req_done(req);
 
1216
}
 
1217
 
 
1218
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1219
{
 
1220
        struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_state *state =
 
1221
                tevent_req_data(req,
 
1222
                struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_state);
 
1223
        NTSTATUS status;
 
1224
 
 
1225
        if (tevent_req_is_nterror(req, &status)) {
 
1226
                tevent_req_received(req);
 
1227
                return status;
 
1228
        }
 
1229
 
 
1230
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1231
 
 
1232
        tevent_req_received(req);
 
1233
        return NT_STATUS_OK;
 
1234
}
 
1235
 
 
1236
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterLogQuery_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRegisterLogQuery *r)
 
1237
{
 
1238
        NTSTATUS status;
 
1239
 
 
1240
        status = dcerpc_binding_handle_call(h,
 
1241
                        NULL, &ndr_table_eventlog6,
 
1242
                        NDR_EVENTLOG6_EVTRPCREGISTERLOGQUERY, mem_ctx, r);
 
1243
 
 
1244
        return status;
 
1245
}
 
1246
 
 
1247
struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state {
 
1248
        struct eventlog6_EvtRpcRegisterLogQuery orig;
 
1249
        struct eventlog6_EvtRpcRegisterLogQuery tmp;
 
1250
        TALLOC_CTX *out_mem_ctx;
 
1251
};
 
1252
 
 
1253
static void dcerpc_eventlog6_EvtRpcRegisterLogQuery_done(struct tevent_req *subreq);
 
1254
 
 
1255
struct tevent_req *dcerpc_eventlog6_EvtRpcRegisterLogQuery_send(TALLOC_CTX *mem_ctx,
 
1256
                                                                struct tevent_context *ev,
 
1257
                                                                struct dcerpc_binding_handle *h,
 
1258
                                                                const char *_path /* [in] [unique,range(0,MAX_RPC_CHANNEL_PATH_LENGTH),charset(UTF16)] */,
 
1259
                                                                const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
1260
                                                                uint32_t _flags /* [in]  */,
 
1261
                                                                struct policy_handle *_handle /* [out] [ref] */,
 
1262
                                                                struct policy_handle *_opControl /* [out] [ref] */,
 
1263
                                                                uint32_t *_queryChannelInfoSize /* [out] [ref] */,
 
1264
                                                                struct eventlog6_EvtRpcQueryChannelInfo **_queryChannelInfo /* [out] [ref,range(0,MAX_RPC_QUERY_CHANNEL_SIZE),size_is(,*queryChannelInfoSize)] */,
 
1265
                                                                struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
1266
{
 
1267
        struct tevent_req *req;
 
1268
        struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state *state;
 
1269
        struct tevent_req *subreq;
 
1270
 
 
1271
        req = tevent_req_create(mem_ctx, &state,
 
1272
                                struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state);
 
1273
        if (req == NULL) {
 
1274
                return NULL;
 
1275
        }
 
1276
        state->out_mem_ctx = NULL;
 
1277
 
 
1278
        /* In parameters */
 
1279
        state->orig.in.path = _path;
 
1280
        state->orig.in.query = _query;
 
1281
        state->orig.in.flags = _flags;
 
1282
 
 
1283
        /* Out parameters */
 
1284
        state->orig.out.handle = _handle;
 
1285
        state->orig.out.opControl = _opControl;
 
1286
        state->orig.out.queryChannelInfoSize = _queryChannelInfoSize;
 
1287
        state->orig.out.queryChannelInfo = _queryChannelInfo;
 
1288
        state->orig.out.error = _error;
 
1289
 
 
1290
        /* Result */
 
1291
        ZERO_STRUCT(state->orig.out.result);
 
1292
 
 
1293
        state->out_mem_ctx = talloc_named_const(state, 0,
 
1294
                             "dcerpc_eventlog6_EvtRpcRegisterLogQuery_out_memory");
 
1295
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1296
                return tevent_req_post(req, ev);
 
1297
        }
 
1298
 
 
1299
        /* make a temporary copy, that we pass to the dispatch function */
 
1300
        state->tmp = state->orig;
 
1301
 
 
1302
        subreq = dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_send(state, ev, h, &state->tmp);
 
1303
        if (tevent_req_nomem(subreq, req)) {
 
1304
                return tevent_req_post(req, ev);
 
1305
        }
 
1306
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRegisterLogQuery_done, req);
 
1307
        return req;
 
1308
}
 
1309
 
 
1310
static void dcerpc_eventlog6_EvtRpcRegisterLogQuery_done(struct tevent_req *subreq)
 
1311
{
 
1312
        struct tevent_req *req = tevent_req_callback_data(
 
1313
                subreq, struct tevent_req);
 
1314
        struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state *state = tevent_req_data(
 
1315
                req, struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state);
 
1316
        NTSTATUS status;
 
1317
        TALLOC_CTX *mem_ctx;
 
1318
 
 
1319
        if (state->out_mem_ctx) {
 
1320
                mem_ctx = state->out_mem_ctx;
 
1321
        } else {
 
1322
                mem_ctx = state;
 
1323
        }
 
1324
 
 
1325
        status = dcerpc_eventlog6_EvtRpcRegisterLogQuery_r_recv(subreq, mem_ctx);
 
1326
        TALLOC_FREE(subreq);
 
1327
        if (!NT_STATUS_IS_OK(status)) {
 
1328
                tevent_req_nterror(req, status);
 
1329
                return;
 
1330
        }
 
1331
 
 
1332
        /* Copy out parameters */
 
1333
        *state->orig.out.handle = *state->tmp.out.handle;
 
1334
        *state->orig.out.opControl = *state->tmp.out.opControl;
 
1335
        *state->orig.out.queryChannelInfoSize = *state->tmp.out.queryChannelInfoSize;
 
1336
        *state->orig.out.queryChannelInfo = *state->tmp.out.queryChannelInfo;
 
1337
        *state->orig.out.error = *state->tmp.out.error;
 
1338
 
 
1339
        /* Copy result */
 
1340
        state->orig.out.result = state->tmp.out.result;
 
1341
 
 
1342
        /* Reset temporary structure */
 
1343
        ZERO_STRUCT(state->tmp);
 
1344
 
 
1345
        tevent_req_done(req);
 
1346
}
 
1347
 
 
1348
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterLogQuery_recv(struct tevent_req *req,
 
1349
                                                      TALLOC_CTX *mem_ctx,
 
1350
                                                      WERROR *result)
 
1351
{
 
1352
        struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state *state = tevent_req_data(
 
1353
                req, struct dcerpc_eventlog6_EvtRpcRegisterLogQuery_state);
 
1354
        NTSTATUS status;
 
1355
 
 
1356
        if (tevent_req_is_nterror(req, &status)) {
 
1357
                tevent_req_received(req);
 
1358
                return status;
 
1359
        }
 
1360
 
 
1361
        /* Steal possible out parameters to the callers context */
 
1362
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1363
 
 
1364
        /* Return result */
 
1365
        *result = state->orig.out.result;
 
1366
 
 
1367
        tevent_req_received(req);
 
1368
        return NT_STATUS_OK;
 
1369
}
 
1370
 
 
1371
NTSTATUS dcerpc_eventlog6_EvtRpcRegisterLogQuery(struct dcerpc_binding_handle *h,
 
1372
                                                 TALLOC_CTX *mem_ctx,
 
1373
                                                 const char *_path /* [in] [unique,range(0,MAX_RPC_CHANNEL_PATH_LENGTH),charset(UTF16)] */,
 
1374
                                                 const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
1375
                                                 uint32_t _flags /* [in]  */,
 
1376
                                                 struct policy_handle *_handle /* [out] [ref] */,
 
1377
                                                 struct policy_handle *_opControl /* [out] [ref] */,
 
1378
                                                 uint32_t *_queryChannelInfoSize /* [out] [ref] */,
 
1379
                                                 struct eventlog6_EvtRpcQueryChannelInfo **_queryChannelInfo /* [out] [ref,range(0,MAX_RPC_QUERY_CHANNEL_SIZE),size_is(,*queryChannelInfoSize)] */,
 
1380
                                                 struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
1381
                                                 WERROR *result)
 
1382
{
 
1383
        struct eventlog6_EvtRpcRegisterLogQuery r;
 
1384
        NTSTATUS status;
 
1385
 
 
1386
        /* In parameters */
 
1387
        r.in.path = _path;
 
1388
        r.in.query = _query;
 
1389
        r.in.flags = _flags;
 
1390
 
 
1391
        status = dcerpc_eventlog6_EvtRpcRegisterLogQuery_r(h, mem_ctx, &r);
 
1392
        if (!NT_STATUS_IS_OK(status)) {
 
1393
                return status;
 
1394
        }
 
1395
 
 
1396
        /* Return variables */
 
1397
        *_handle = *r.out.handle;
 
1398
        *_opControl = *r.out.opControl;
 
1399
        *_queryChannelInfoSize = *r.out.queryChannelInfoSize;
 
1400
        *_queryChannelInfo = *r.out.queryChannelInfo;
 
1401
        *_error = *r.out.error;
 
1402
 
 
1403
        /* Return result */
 
1404
        *result = r.out.result;
 
1405
 
 
1406
        return NT_STATUS_OK;
 
1407
}
 
1408
 
 
1409
struct dcerpc_eventlog6_EvtRpcClearLog_r_state {
 
1410
        TALLOC_CTX *out_mem_ctx;
 
1411
};
 
1412
 
 
1413
static void dcerpc_eventlog6_EvtRpcClearLog_r_done(struct tevent_req *subreq);
 
1414
 
 
1415
struct tevent_req *dcerpc_eventlog6_EvtRpcClearLog_r_send(TALLOC_CTX *mem_ctx,
 
1416
        struct tevent_context *ev,
 
1417
        struct dcerpc_binding_handle *h,
 
1418
        struct eventlog6_EvtRpcClearLog *r)
 
1419
{
 
1420
        struct tevent_req *req;
 
1421
        struct dcerpc_eventlog6_EvtRpcClearLog_r_state *state;
 
1422
        struct tevent_req *subreq;
 
1423
 
 
1424
        req = tevent_req_create(mem_ctx, &state,
 
1425
                                struct dcerpc_eventlog6_EvtRpcClearLog_r_state);
 
1426
        if (req == NULL) {
 
1427
                return NULL;
 
1428
        }
 
1429
 
 
1430
        state->out_mem_ctx = talloc_new(state);
 
1431
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1432
                return tevent_req_post(req, ev);
 
1433
        }
 
1434
 
 
1435
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1436
                        NULL, &ndr_table_eventlog6,
 
1437
                        NDR_EVENTLOG6_EVTRPCCLEARLOG, state->out_mem_ctx, r);
 
1438
        if (tevent_req_nomem(subreq, req)) {
 
1439
                return tevent_req_post(req, ev);
 
1440
        }
 
1441
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcClearLog_r_done, req);
 
1442
 
 
1443
        return req;
 
1444
}
 
1445
 
 
1446
static void dcerpc_eventlog6_EvtRpcClearLog_r_done(struct tevent_req *subreq)
 
1447
{
 
1448
        struct tevent_req *req =
 
1449
                tevent_req_callback_data(subreq,
 
1450
                struct tevent_req);
 
1451
        NTSTATUS status;
 
1452
 
 
1453
        status = dcerpc_binding_handle_call_recv(subreq);
 
1454
        if (!NT_STATUS_IS_OK(status)) {
 
1455
                tevent_req_nterror(req, status);
 
1456
                return;
 
1457
        }
 
1458
 
 
1459
        tevent_req_done(req);
 
1460
}
 
1461
 
 
1462
NTSTATUS dcerpc_eventlog6_EvtRpcClearLog_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1463
{
 
1464
        struct dcerpc_eventlog6_EvtRpcClearLog_r_state *state =
 
1465
                tevent_req_data(req,
 
1466
                struct dcerpc_eventlog6_EvtRpcClearLog_r_state);
 
1467
        NTSTATUS status;
 
1468
 
 
1469
        if (tevent_req_is_nterror(req, &status)) {
 
1470
                tevent_req_received(req);
 
1471
                return status;
 
1472
        }
 
1473
 
 
1474
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1475
 
 
1476
        tevent_req_received(req);
 
1477
        return NT_STATUS_OK;
 
1478
}
 
1479
 
 
1480
NTSTATUS dcerpc_eventlog6_EvtRpcClearLog_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcClearLog *r)
 
1481
{
 
1482
        NTSTATUS status;
 
1483
 
 
1484
        status = dcerpc_binding_handle_call(h,
 
1485
                        NULL, &ndr_table_eventlog6,
 
1486
                        NDR_EVENTLOG6_EVTRPCCLEARLOG, mem_ctx, r);
 
1487
 
 
1488
        return status;
 
1489
}
 
1490
 
 
1491
struct dcerpc_eventlog6_EvtRpcClearLog_state {
 
1492
        struct eventlog6_EvtRpcClearLog orig;
 
1493
        struct eventlog6_EvtRpcClearLog tmp;
 
1494
        TALLOC_CTX *out_mem_ctx;
 
1495
};
 
1496
 
 
1497
static void dcerpc_eventlog6_EvtRpcClearLog_done(struct tevent_req *subreq);
 
1498
 
 
1499
struct tevent_req *dcerpc_eventlog6_EvtRpcClearLog_send(TALLOC_CTX *mem_ctx,
 
1500
                                                        struct tevent_context *ev,
 
1501
                                                        struct dcerpc_binding_handle *h,
 
1502
                                                        struct policy_handle *_control /* [in] [ref] */,
 
1503
                                                        const char *_channelPath /* [in] [ref,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
1504
                                                        const char *_backupPath /* [in] [unique,range(0,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
1505
                                                        uint32_t _flags /* [in]  */,
 
1506
                                                        struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
1507
{
 
1508
        struct tevent_req *req;
 
1509
        struct dcerpc_eventlog6_EvtRpcClearLog_state *state;
 
1510
        struct tevent_req *subreq;
 
1511
 
 
1512
        req = tevent_req_create(mem_ctx, &state,
 
1513
                                struct dcerpc_eventlog6_EvtRpcClearLog_state);
 
1514
        if (req == NULL) {
 
1515
                return NULL;
 
1516
        }
 
1517
        state->out_mem_ctx = NULL;
 
1518
 
 
1519
        /* In parameters */
 
1520
        state->orig.in.control = _control;
 
1521
        state->orig.in.channelPath = _channelPath;
 
1522
        state->orig.in.backupPath = _backupPath;
 
1523
        state->orig.in.flags = _flags;
 
1524
 
 
1525
        /* Out parameters */
 
1526
        state->orig.out.error = _error;
 
1527
 
 
1528
        /* Result */
 
1529
        ZERO_STRUCT(state->orig.out.result);
 
1530
 
 
1531
        state->out_mem_ctx = talloc_named_const(state, 0,
 
1532
                             "dcerpc_eventlog6_EvtRpcClearLog_out_memory");
 
1533
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1534
                return tevent_req_post(req, ev);
 
1535
        }
 
1536
 
 
1537
        /* make a temporary copy, that we pass to the dispatch function */
 
1538
        state->tmp = state->orig;
 
1539
 
 
1540
        subreq = dcerpc_eventlog6_EvtRpcClearLog_r_send(state, ev, h, &state->tmp);
 
1541
        if (tevent_req_nomem(subreq, req)) {
 
1542
                return tevent_req_post(req, ev);
 
1543
        }
 
1544
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcClearLog_done, req);
 
1545
        return req;
 
1546
}
 
1547
 
 
1548
static void dcerpc_eventlog6_EvtRpcClearLog_done(struct tevent_req *subreq)
 
1549
{
 
1550
        struct tevent_req *req = tevent_req_callback_data(
 
1551
                subreq, struct tevent_req);
 
1552
        struct dcerpc_eventlog6_EvtRpcClearLog_state *state = tevent_req_data(
 
1553
                req, struct dcerpc_eventlog6_EvtRpcClearLog_state);
 
1554
        NTSTATUS status;
 
1555
        TALLOC_CTX *mem_ctx;
 
1556
 
 
1557
        if (state->out_mem_ctx) {
 
1558
                mem_ctx = state->out_mem_ctx;
 
1559
        } else {
 
1560
                mem_ctx = state;
 
1561
        }
 
1562
 
 
1563
        status = dcerpc_eventlog6_EvtRpcClearLog_r_recv(subreq, mem_ctx);
 
1564
        TALLOC_FREE(subreq);
 
1565
        if (!NT_STATUS_IS_OK(status)) {
 
1566
                tevent_req_nterror(req, status);
 
1567
                return;
 
1568
        }
 
1569
 
 
1570
        /* Copy out parameters */
 
1571
        *state->orig.out.error = *state->tmp.out.error;
 
1572
 
 
1573
        /* Copy result */
 
1574
        state->orig.out.result = state->tmp.out.result;
 
1575
 
 
1576
        /* Reset temporary structure */
 
1577
        ZERO_STRUCT(state->tmp);
 
1578
 
 
1579
        tevent_req_done(req);
 
1580
}
 
1581
 
 
1582
NTSTATUS dcerpc_eventlog6_EvtRpcClearLog_recv(struct tevent_req *req,
 
1583
                                              TALLOC_CTX *mem_ctx,
 
1584
                                              WERROR *result)
 
1585
{
 
1586
        struct dcerpc_eventlog6_EvtRpcClearLog_state *state = tevent_req_data(
 
1587
                req, struct dcerpc_eventlog6_EvtRpcClearLog_state);
 
1588
        NTSTATUS status;
 
1589
 
 
1590
        if (tevent_req_is_nterror(req, &status)) {
 
1591
                tevent_req_received(req);
 
1592
                return status;
 
1593
        }
 
1594
 
 
1595
        /* Steal possible out parameters to the callers context */
 
1596
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1597
 
 
1598
        /* Return result */
 
1599
        *result = state->orig.out.result;
 
1600
 
 
1601
        tevent_req_received(req);
 
1602
        return NT_STATUS_OK;
 
1603
}
 
1604
 
 
1605
NTSTATUS dcerpc_eventlog6_EvtRpcClearLog(struct dcerpc_binding_handle *h,
 
1606
                                         TALLOC_CTX *mem_ctx,
 
1607
                                         struct policy_handle *_control /* [in] [ref] */,
 
1608
                                         const char *_channelPath /* [in] [ref,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
1609
                                         const char *_backupPath /* [in] [unique,range(0,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
1610
                                         uint32_t _flags /* [in]  */,
 
1611
                                         struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
1612
                                         WERROR *result)
 
1613
{
 
1614
        struct eventlog6_EvtRpcClearLog r;
 
1615
        NTSTATUS status;
 
1616
 
 
1617
        /* In parameters */
 
1618
        r.in.control = _control;
 
1619
        r.in.channelPath = _channelPath;
 
1620
        r.in.backupPath = _backupPath;
 
1621
        r.in.flags = _flags;
 
1622
 
 
1623
        status = dcerpc_eventlog6_EvtRpcClearLog_r(h, mem_ctx, &r);
 
1624
        if (!NT_STATUS_IS_OK(status)) {
 
1625
                return status;
 
1626
        }
 
1627
 
 
1628
        /* Return variables */
 
1629
        *_error = *r.out.error;
 
1630
 
 
1631
        /* Return result */
 
1632
        *result = r.out.result;
 
1633
 
 
1634
        return NT_STATUS_OK;
 
1635
}
 
1636
 
 
1637
struct dcerpc_eventlog6_EvtRpcExportLog_r_state {
 
1638
        TALLOC_CTX *out_mem_ctx;
 
1639
};
 
1640
 
 
1641
static void dcerpc_eventlog6_EvtRpcExportLog_r_done(struct tevent_req *subreq);
 
1642
 
 
1643
struct tevent_req *dcerpc_eventlog6_EvtRpcExportLog_r_send(TALLOC_CTX *mem_ctx,
 
1644
        struct tevent_context *ev,
 
1645
        struct dcerpc_binding_handle *h,
 
1646
        struct eventlog6_EvtRpcExportLog *r)
 
1647
{
 
1648
        struct tevent_req *req;
 
1649
        struct dcerpc_eventlog6_EvtRpcExportLog_r_state *state;
 
1650
        struct tevent_req *subreq;
 
1651
 
 
1652
        req = tevent_req_create(mem_ctx, &state,
 
1653
                                struct dcerpc_eventlog6_EvtRpcExportLog_r_state);
 
1654
        if (req == NULL) {
 
1655
                return NULL;
 
1656
        }
 
1657
 
 
1658
        state->out_mem_ctx = talloc_new(state);
 
1659
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1660
                return tevent_req_post(req, ev);
 
1661
        }
 
1662
 
 
1663
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1664
                        NULL, &ndr_table_eventlog6,
 
1665
                        NDR_EVENTLOG6_EVTRPCEXPORTLOG, state->out_mem_ctx, r);
 
1666
        if (tevent_req_nomem(subreq, req)) {
 
1667
                return tevent_req_post(req, ev);
 
1668
        }
 
1669
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcExportLog_r_done, req);
 
1670
 
 
1671
        return req;
 
1672
}
 
1673
 
 
1674
static void dcerpc_eventlog6_EvtRpcExportLog_r_done(struct tevent_req *subreq)
 
1675
{
 
1676
        struct tevent_req *req =
 
1677
                tevent_req_callback_data(subreq,
 
1678
                struct tevent_req);
 
1679
        NTSTATUS status;
 
1680
 
 
1681
        status = dcerpc_binding_handle_call_recv(subreq);
 
1682
        if (!NT_STATUS_IS_OK(status)) {
 
1683
                tevent_req_nterror(req, status);
 
1684
                return;
 
1685
        }
 
1686
 
 
1687
        tevent_req_done(req);
 
1688
}
 
1689
 
 
1690
NTSTATUS dcerpc_eventlog6_EvtRpcExportLog_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1691
{
 
1692
        struct dcerpc_eventlog6_EvtRpcExportLog_r_state *state =
 
1693
                tevent_req_data(req,
 
1694
                struct dcerpc_eventlog6_EvtRpcExportLog_r_state);
 
1695
        NTSTATUS status;
 
1696
 
 
1697
        if (tevent_req_is_nterror(req, &status)) {
 
1698
                tevent_req_received(req);
 
1699
                return status;
 
1700
        }
 
1701
 
 
1702
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1703
 
 
1704
        tevent_req_received(req);
 
1705
        return NT_STATUS_OK;
 
1706
}
 
1707
 
 
1708
NTSTATUS dcerpc_eventlog6_EvtRpcExportLog_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcExportLog *r)
 
1709
{
 
1710
        NTSTATUS status;
 
1711
 
 
1712
        status = dcerpc_binding_handle_call(h,
 
1713
                        NULL, &ndr_table_eventlog6,
 
1714
                        NDR_EVENTLOG6_EVTRPCEXPORTLOG, mem_ctx, r);
 
1715
 
 
1716
        return status;
 
1717
}
 
1718
 
 
1719
struct dcerpc_eventlog6_EvtRpcExportLog_state {
 
1720
        struct eventlog6_EvtRpcExportLog orig;
 
1721
        struct eventlog6_EvtRpcExportLog tmp;
 
1722
        TALLOC_CTX *out_mem_ctx;
 
1723
};
 
1724
 
 
1725
static void dcerpc_eventlog6_EvtRpcExportLog_done(struct tevent_req *subreq);
 
1726
 
 
1727
struct tevent_req *dcerpc_eventlog6_EvtRpcExportLog_send(TALLOC_CTX *mem_ctx,
 
1728
                                                         struct tevent_context *ev,
 
1729
                                                         struct dcerpc_binding_handle *h,
 
1730
                                                         struct policy_handle *_control /* [in] [ref] */,
 
1731
                                                         const char *_channelPath /* [in] [unique,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
1732
                                                         const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
1733
                                                         const char *_backupPath /* [in] [ref,range(1,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
1734
                                                         uint32_t _flags /* [in]  */,
 
1735
                                                         struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
1736
{
 
1737
        struct tevent_req *req;
 
1738
        struct dcerpc_eventlog6_EvtRpcExportLog_state *state;
 
1739
        struct tevent_req *subreq;
 
1740
 
 
1741
        req = tevent_req_create(mem_ctx, &state,
 
1742
                                struct dcerpc_eventlog6_EvtRpcExportLog_state);
 
1743
        if (req == NULL) {
 
1744
                return NULL;
 
1745
        }
 
1746
        state->out_mem_ctx = NULL;
 
1747
 
 
1748
        /* In parameters */
 
1749
        state->orig.in.control = _control;
 
1750
        state->orig.in.channelPath = _channelPath;
 
1751
        state->orig.in.query = _query;
 
1752
        state->orig.in.backupPath = _backupPath;
 
1753
        state->orig.in.flags = _flags;
 
1754
 
 
1755
        /* Out parameters */
 
1756
        state->orig.out.error = _error;
 
1757
 
 
1758
        /* Result */
 
1759
        ZERO_STRUCT(state->orig.out.result);
 
1760
 
 
1761
        state->out_mem_ctx = talloc_named_const(state, 0,
 
1762
                             "dcerpc_eventlog6_EvtRpcExportLog_out_memory");
 
1763
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1764
                return tevent_req_post(req, ev);
 
1765
        }
 
1766
 
 
1767
        /* make a temporary copy, that we pass to the dispatch function */
 
1768
        state->tmp = state->orig;
 
1769
 
 
1770
        subreq = dcerpc_eventlog6_EvtRpcExportLog_r_send(state, ev, h, &state->tmp);
 
1771
        if (tevent_req_nomem(subreq, req)) {
 
1772
                return tevent_req_post(req, ev);
 
1773
        }
 
1774
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcExportLog_done, req);
 
1775
        return req;
 
1776
}
 
1777
 
 
1778
static void dcerpc_eventlog6_EvtRpcExportLog_done(struct tevent_req *subreq)
 
1779
{
 
1780
        struct tevent_req *req = tevent_req_callback_data(
 
1781
                subreq, struct tevent_req);
 
1782
        struct dcerpc_eventlog6_EvtRpcExportLog_state *state = tevent_req_data(
 
1783
                req, struct dcerpc_eventlog6_EvtRpcExportLog_state);
 
1784
        NTSTATUS status;
 
1785
        TALLOC_CTX *mem_ctx;
 
1786
 
 
1787
        if (state->out_mem_ctx) {
 
1788
                mem_ctx = state->out_mem_ctx;
 
1789
        } else {
 
1790
                mem_ctx = state;
 
1791
        }
 
1792
 
 
1793
        status = dcerpc_eventlog6_EvtRpcExportLog_r_recv(subreq, mem_ctx);
 
1794
        TALLOC_FREE(subreq);
 
1795
        if (!NT_STATUS_IS_OK(status)) {
 
1796
                tevent_req_nterror(req, status);
 
1797
                return;
 
1798
        }
 
1799
 
 
1800
        /* Copy out parameters */
 
1801
        *state->orig.out.error = *state->tmp.out.error;
 
1802
 
 
1803
        /* Copy result */
 
1804
        state->orig.out.result = state->tmp.out.result;
 
1805
 
 
1806
        /* Reset temporary structure */
 
1807
        ZERO_STRUCT(state->tmp);
 
1808
 
 
1809
        tevent_req_done(req);
 
1810
}
 
1811
 
 
1812
NTSTATUS dcerpc_eventlog6_EvtRpcExportLog_recv(struct tevent_req *req,
 
1813
                                               TALLOC_CTX *mem_ctx,
 
1814
                                               WERROR *result)
 
1815
{
 
1816
        struct dcerpc_eventlog6_EvtRpcExportLog_state *state = tevent_req_data(
 
1817
                req, struct dcerpc_eventlog6_EvtRpcExportLog_state);
 
1818
        NTSTATUS status;
 
1819
 
 
1820
        if (tevent_req_is_nterror(req, &status)) {
 
1821
                tevent_req_received(req);
 
1822
                return status;
 
1823
        }
 
1824
 
 
1825
        /* Steal possible out parameters to the callers context */
 
1826
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1827
 
 
1828
        /* Return result */
 
1829
        *result = state->orig.out.result;
 
1830
 
 
1831
        tevent_req_received(req);
 
1832
        return NT_STATUS_OK;
 
1833
}
 
1834
 
 
1835
NTSTATUS dcerpc_eventlog6_EvtRpcExportLog(struct dcerpc_binding_handle *h,
 
1836
                                          TALLOC_CTX *mem_ctx,
 
1837
                                          struct policy_handle *_control /* [in] [ref] */,
 
1838
                                          const char *_channelPath /* [in] [unique,range(0,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
1839
                                          const char *_query /* [in] [ref,range(1,MAX_RPC_QUERY_LENGTH),charset(UTF16)] */,
 
1840
                                          const char *_backupPath /* [in] [ref,range(1,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
1841
                                          uint32_t _flags /* [in]  */,
 
1842
                                          struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
1843
                                          WERROR *result)
 
1844
{
 
1845
        struct eventlog6_EvtRpcExportLog r;
 
1846
        NTSTATUS status;
 
1847
 
 
1848
        /* In parameters */
 
1849
        r.in.control = _control;
 
1850
        r.in.channelPath = _channelPath;
 
1851
        r.in.query = _query;
 
1852
        r.in.backupPath = _backupPath;
 
1853
        r.in.flags = _flags;
 
1854
 
 
1855
        status = dcerpc_eventlog6_EvtRpcExportLog_r(h, mem_ctx, &r);
 
1856
        if (!NT_STATUS_IS_OK(status)) {
 
1857
                return status;
 
1858
        }
 
1859
 
 
1860
        /* Return variables */
 
1861
        *_error = *r.out.error;
 
1862
 
 
1863
        /* Return result */
 
1864
        *result = r.out.result;
 
1865
 
 
1866
        return NT_STATUS_OK;
 
1867
}
 
1868
 
 
1869
struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_state {
 
1870
        TALLOC_CTX *out_mem_ctx;
 
1871
};
 
1872
 
 
1873
static void dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_done(struct tevent_req *subreq);
 
1874
 
 
1875
struct tevent_req *dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_send(TALLOC_CTX *mem_ctx,
 
1876
        struct tevent_context *ev,
 
1877
        struct dcerpc_binding_handle *h,
 
1878
        struct eventlog6_EvtRpcLocalizeExportLog *r)
 
1879
{
 
1880
        struct tevent_req *req;
 
1881
        struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_state *state;
 
1882
        struct tevent_req *subreq;
 
1883
 
 
1884
        req = tevent_req_create(mem_ctx, &state,
 
1885
                                struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_state);
 
1886
        if (req == NULL) {
 
1887
                return NULL;
 
1888
        }
 
1889
 
 
1890
        state->out_mem_ctx = talloc_new(state);
 
1891
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1892
                return tevent_req_post(req, ev);
 
1893
        }
 
1894
 
 
1895
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1896
                        NULL, &ndr_table_eventlog6,
 
1897
                        NDR_EVENTLOG6_EVTRPCLOCALIZEEXPORTLOG, state->out_mem_ctx, r);
 
1898
        if (tevent_req_nomem(subreq, req)) {
 
1899
                return tevent_req_post(req, ev);
 
1900
        }
 
1901
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_done, req);
 
1902
 
 
1903
        return req;
 
1904
}
 
1905
 
 
1906
static void dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_done(struct tevent_req *subreq)
 
1907
{
 
1908
        struct tevent_req *req =
 
1909
                tevent_req_callback_data(subreq,
 
1910
                struct tevent_req);
 
1911
        NTSTATUS status;
 
1912
 
 
1913
        status = dcerpc_binding_handle_call_recv(subreq);
 
1914
        if (!NT_STATUS_IS_OK(status)) {
 
1915
                tevent_req_nterror(req, status);
 
1916
                return;
 
1917
        }
 
1918
 
 
1919
        tevent_req_done(req);
 
1920
}
 
1921
 
 
1922
NTSTATUS dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1923
{
 
1924
        struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_state *state =
 
1925
                tevent_req_data(req,
 
1926
                struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_state);
 
1927
        NTSTATUS status;
 
1928
 
 
1929
        if (tevent_req_is_nterror(req, &status)) {
 
1930
                tevent_req_received(req);
 
1931
                return status;
 
1932
        }
 
1933
 
 
1934
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1935
 
 
1936
        tevent_req_received(req);
 
1937
        return NT_STATUS_OK;
 
1938
}
 
1939
 
 
1940
NTSTATUS dcerpc_eventlog6_EvtRpcLocalizeExportLog_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcLocalizeExportLog *r)
 
1941
{
 
1942
        NTSTATUS status;
 
1943
 
 
1944
        status = dcerpc_binding_handle_call(h,
 
1945
                        NULL, &ndr_table_eventlog6,
 
1946
                        NDR_EVENTLOG6_EVTRPCLOCALIZEEXPORTLOG, mem_ctx, r);
 
1947
 
 
1948
        return status;
 
1949
}
 
1950
 
 
1951
struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state {
 
1952
        struct eventlog6_EvtRpcLocalizeExportLog orig;
 
1953
        struct eventlog6_EvtRpcLocalizeExportLog tmp;
 
1954
        TALLOC_CTX *out_mem_ctx;
 
1955
};
 
1956
 
 
1957
static void dcerpc_eventlog6_EvtRpcLocalizeExportLog_done(struct tevent_req *subreq);
 
1958
 
 
1959
struct tevent_req *dcerpc_eventlog6_EvtRpcLocalizeExportLog_send(TALLOC_CTX *mem_ctx,
 
1960
                                                                 struct tevent_context *ev,
 
1961
                                                                 struct dcerpc_binding_handle *h,
 
1962
                                                                 struct policy_handle *_control /* [in] [ref] */,
 
1963
                                                                 const char *_logFilePath /* [in] [ref,range(1,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
1964
                                                                 uint32_t _locale /* [in]  */,
 
1965
                                                                 uint32_t _flags /* [in]  */,
 
1966
                                                                 struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
1967
{
 
1968
        struct tevent_req *req;
 
1969
        struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state *state;
 
1970
        struct tevent_req *subreq;
 
1971
 
 
1972
        req = tevent_req_create(mem_ctx, &state,
 
1973
                                struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state);
 
1974
        if (req == NULL) {
 
1975
                return NULL;
 
1976
        }
 
1977
        state->out_mem_ctx = NULL;
 
1978
 
 
1979
        /* In parameters */
 
1980
        state->orig.in.control = _control;
 
1981
        state->orig.in.logFilePath = _logFilePath;
 
1982
        state->orig.in.locale = _locale;
 
1983
        state->orig.in.flags = _flags;
 
1984
 
 
1985
        /* Out parameters */
 
1986
        state->orig.out.error = _error;
 
1987
 
 
1988
        /* Result */
 
1989
        ZERO_STRUCT(state->orig.out.result);
 
1990
 
 
1991
        state->out_mem_ctx = talloc_named_const(state, 0,
 
1992
                             "dcerpc_eventlog6_EvtRpcLocalizeExportLog_out_memory");
 
1993
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1994
                return tevent_req_post(req, ev);
 
1995
        }
 
1996
 
 
1997
        /* make a temporary copy, that we pass to the dispatch function */
 
1998
        state->tmp = state->orig;
 
1999
 
 
2000
        subreq = dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_send(state, ev, h, &state->tmp);
 
2001
        if (tevent_req_nomem(subreq, req)) {
 
2002
                return tevent_req_post(req, ev);
 
2003
        }
 
2004
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcLocalizeExportLog_done, req);
 
2005
        return req;
 
2006
}
 
2007
 
 
2008
static void dcerpc_eventlog6_EvtRpcLocalizeExportLog_done(struct tevent_req *subreq)
 
2009
{
 
2010
        struct tevent_req *req = tevent_req_callback_data(
 
2011
                subreq, struct tevent_req);
 
2012
        struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state *state = tevent_req_data(
 
2013
                req, struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state);
 
2014
        NTSTATUS status;
 
2015
        TALLOC_CTX *mem_ctx;
 
2016
 
 
2017
        if (state->out_mem_ctx) {
 
2018
                mem_ctx = state->out_mem_ctx;
 
2019
        } else {
 
2020
                mem_ctx = state;
 
2021
        }
 
2022
 
 
2023
        status = dcerpc_eventlog6_EvtRpcLocalizeExportLog_r_recv(subreq, mem_ctx);
 
2024
        TALLOC_FREE(subreq);
 
2025
        if (!NT_STATUS_IS_OK(status)) {
 
2026
                tevent_req_nterror(req, status);
 
2027
                return;
 
2028
        }
 
2029
 
 
2030
        /* Copy out parameters */
 
2031
        *state->orig.out.error = *state->tmp.out.error;
 
2032
 
 
2033
        /* Copy result */
 
2034
        state->orig.out.result = state->tmp.out.result;
 
2035
 
 
2036
        /* Reset temporary structure */
 
2037
        ZERO_STRUCT(state->tmp);
 
2038
 
 
2039
        tevent_req_done(req);
 
2040
}
 
2041
 
 
2042
NTSTATUS dcerpc_eventlog6_EvtRpcLocalizeExportLog_recv(struct tevent_req *req,
 
2043
                                                       TALLOC_CTX *mem_ctx,
 
2044
                                                       WERROR *result)
 
2045
{
 
2046
        struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state *state = tevent_req_data(
 
2047
                req, struct dcerpc_eventlog6_EvtRpcLocalizeExportLog_state);
 
2048
        NTSTATUS status;
 
2049
 
 
2050
        if (tevent_req_is_nterror(req, &status)) {
 
2051
                tevent_req_received(req);
 
2052
                return status;
 
2053
        }
 
2054
 
 
2055
        /* Steal possible out parameters to the callers context */
 
2056
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2057
 
 
2058
        /* Return result */
 
2059
        *result = state->orig.out.result;
 
2060
 
 
2061
        tevent_req_received(req);
 
2062
        return NT_STATUS_OK;
 
2063
}
 
2064
 
 
2065
NTSTATUS dcerpc_eventlog6_EvtRpcLocalizeExportLog(struct dcerpc_binding_handle *h,
 
2066
                                                  TALLOC_CTX *mem_ctx,
 
2067
                                                  struct policy_handle *_control /* [in] [ref] */,
 
2068
                                                  const char *_logFilePath /* [in] [ref,range(1,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
2069
                                                  uint32_t _locale /* [in]  */,
 
2070
                                                  uint32_t _flags /* [in]  */,
 
2071
                                                  struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
2072
                                                  WERROR *result)
 
2073
{
 
2074
        struct eventlog6_EvtRpcLocalizeExportLog r;
 
2075
        NTSTATUS status;
 
2076
 
 
2077
        /* In parameters */
 
2078
        r.in.control = _control;
 
2079
        r.in.logFilePath = _logFilePath;
 
2080
        r.in.locale = _locale;
 
2081
        r.in.flags = _flags;
 
2082
 
 
2083
        status = dcerpc_eventlog6_EvtRpcLocalizeExportLog_r(h, mem_ctx, &r);
 
2084
        if (!NT_STATUS_IS_OK(status)) {
 
2085
                return status;
 
2086
        }
 
2087
 
 
2088
        /* Return variables */
 
2089
        *_error = *r.out.error;
 
2090
 
 
2091
        /* Return result */
 
2092
        *result = r.out.result;
 
2093
 
 
2094
        return NT_STATUS_OK;
 
2095
}
 
2096
 
 
2097
struct dcerpc_eventlog6_EvtRpcMessageRender_r_state {
 
2098
        TALLOC_CTX *out_mem_ctx;
 
2099
};
 
2100
 
 
2101
static void dcerpc_eventlog6_EvtRpcMessageRender_r_done(struct tevent_req *subreq);
 
2102
 
 
2103
struct tevent_req *dcerpc_eventlog6_EvtRpcMessageRender_r_send(TALLOC_CTX *mem_ctx,
 
2104
        struct tevent_context *ev,
 
2105
        struct dcerpc_binding_handle *h,
 
2106
        struct eventlog6_EvtRpcMessageRender *r)
 
2107
{
 
2108
        struct tevent_req *req;
 
2109
        struct dcerpc_eventlog6_EvtRpcMessageRender_r_state *state;
 
2110
        struct tevent_req *subreq;
 
2111
 
 
2112
        req = tevent_req_create(mem_ctx, &state,
 
2113
                                struct dcerpc_eventlog6_EvtRpcMessageRender_r_state);
 
2114
        if (req == NULL) {
 
2115
                return NULL;
 
2116
        }
 
2117
 
 
2118
        state->out_mem_ctx = talloc_new(state);
 
2119
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2120
                return tevent_req_post(req, ev);
 
2121
        }
 
2122
 
 
2123
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
2124
                        NULL, &ndr_table_eventlog6,
 
2125
                        NDR_EVENTLOG6_EVTRPCMESSAGERENDER, state->out_mem_ctx, r);
 
2126
        if (tevent_req_nomem(subreq, req)) {
 
2127
                return tevent_req_post(req, ev);
 
2128
        }
 
2129
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcMessageRender_r_done, req);
 
2130
 
 
2131
        return req;
 
2132
}
 
2133
 
 
2134
static void dcerpc_eventlog6_EvtRpcMessageRender_r_done(struct tevent_req *subreq)
 
2135
{
 
2136
        struct tevent_req *req =
 
2137
                tevent_req_callback_data(subreq,
 
2138
                struct tevent_req);
 
2139
        NTSTATUS status;
 
2140
 
 
2141
        status = dcerpc_binding_handle_call_recv(subreq);
 
2142
        if (!NT_STATUS_IS_OK(status)) {
 
2143
                tevent_req_nterror(req, status);
 
2144
                return;
 
2145
        }
 
2146
 
 
2147
        tevent_req_done(req);
 
2148
}
 
2149
 
 
2150
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRender_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
2151
{
 
2152
        struct dcerpc_eventlog6_EvtRpcMessageRender_r_state *state =
 
2153
                tevent_req_data(req,
 
2154
                struct dcerpc_eventlog6_EvtRpcMessageRender_r_state);
 
2155
        NTSTATUS status;
 
2156
 
 
2157
        if (tevent_req_is_nterror(req, &status)) {
 
2158
                tevent_req_received(req);
 
2159
                return status;
 
2160
        }
 
2161
 
 
2162
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2163
 
 
2164
        tevent_req_received(req);
 
2165
        return NT_STATUS_OK;
 
2166
}
 
2167
 
 
2168
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRender_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcMessageRender *r)
 
2169
{
 
2170
        NTSTATUS status;
 
2171
 
 
2172
        status = dcerpc_binding_handle_call(h,
 
2173
                        NULL, &ndr_table_eventlog6,
 
2174
                        NDR_EVENTLOG6_EVTRPCMESSAGERENDER, mem_ctx, r);
 
2175
 
 
2176
        return status;
 
2177
}
 
2178
 
 
2179
struct dcerpc_eventlog6_EvtRpcMessageRender_state {
 
2180
        struct eventlog6_EvtRpcMessageRender orig;
 
2181
        struct eventlog6_EvtRpcMessageRender tmp;
 
2182
        TALLOC_CTX *out_mem_ctx;
 
2183
};
 
2184
 
 
2185
static void dcerpc_eventlog6_EvtRpcMessageRender_done(struct tevent_req *subreq);
 
2186
 
 
2187
struct tevent_req *dcerpc_eventlog6_EvtRpcMessageRender_send(TALLOC_CTX *mem_ctx,
 
2188
                                                             struct tevent_context *ev,
 
2189
                                                             struct dcerpc_binding_handle *h,
 
2190
                                                             struct policy_handle *_pubCfgObj /* [in] [ref] */,
 
2191
                                                             uint32_t _sizeEventId /* [in] [range(1,MAX_RPC_EVENT_ID_SIZE)] */,
 
2192
                                                             uint8_t *_eventId /* [in] [ref,size_is(sizeEventId)] */,
 
2193
                                                             uint32_t _messageId /* [in]  */,
 
2194
                                                             struct eventlog6_EvtRpcVariantList *_values /* [in] [ref] */,
 
2195
                                                             uint32_t _flags /* [in]  */,
 
2196
                                                             uint32_t _maxSizeString /* [in]  */,
 
2197
                                                             uint32_t *_actualSizeString /* [out] [ref] */,
 
2198
                                                             uint32_t *_neededSizeString /* [out] [ref] */,
 
2199
                                                             uint8_t **_string /* [out] [ref,range(0,MAX_RPC_RENDERED_STRING_SIZE),size_is(,*actualSizeString)] */,
 
2200
                                                             struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
2201
{
 
2202
        struct tevent_req *req;
 
2203
        struct dcerpc_eventlog6_EvtRpcMessageRender_state *state;
 
2204
        struct tevent_req *subreq;
 
2205
 
 
2206
        req = tevent_req_create(mem_ctx, &state,
 
2207
                                struct dcerpc_eventlog6_EvtRpcMessageRender_state);
 
2208
        if (req == NULL) {
 
2209
                return NULL;
 
2210
        }
 
2211
        state->out_mem_ctx = NULL;
 
2212
 
 
2213
        /* In parameters */
 
2214
        state->orig.in.pubCfgObj = _pubCfgObj;
 
2215
        state->orig.in.sizeEventId = _sizeEventId;
 
2216
        state->orig.in.eventId = _eventId;
 
2217
        state->orig.in.messageId = _messageId;
 
2218
        state->orig.in.values = _values;
 
2219
        state->orig.in.flags = _flags;
 
2220
        state->orig.in.maxSizeString = _maxSizeString;
 
2221
 
 
2222
        /* Out parameters */
 
2223
        state->orig.out.actualSizeString = _actualSizeString;
 
2224
        state->orig.out.neededSizeString = _neededSizeString;
 
2225
        state->orig.out.string = _string;
 
2226
        state->orig.out.error = _error;
 
2227
 
 
2228
        /* Result */
 
2229
        ZERO_STRUCT(state->orig.out.result);
 
2230
 
 
2231
        state->out_mem_ctx = talloc_named_const(state, 0,
 
2232
                             "dcerpc_eventlog6_EvtRpcMessageRender_out_memory");
 
2233
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2234
                return tevent_req_post(req, ev);
 
2235
        }
 
2236
 
 
2237
        /* make a temporary copy, that we pass to the dispatch function */
 
2238
        state->tmp = state->orig;
 
2239
 
 
2240
        subreq = dcerpc_eventlog6_EvtRpcMessageRender_r_send(state, ev, h, &state->tmp);
 
2241
        if (tevent_req_nomem(subreq, req)) {
 
2242
                return tevent_req_post(req, ev);
 
2243
        }
 
2244
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcMessageRender_done, req);
 
2245
        return req;
 
2246
}
 
2247
 
 
2248
static void dcerpc_eventlog6_EvtRpcMessageRender_done(struct tevent_req *subreq)
 
2249
{
 
2250
        struct tevent_req *req = tevent_req_callback_data(
 
2251
                subreq, struct tevent_req);
 
2252
        struct dcerpc_eventlog6_EvtRpcMessageRender_state *state = tevent_req_data(
 
2253
                req, struct dcerpc_eventlog6_EvtRpcMessageRender_state);
 
2254
        NTSTATUS status;
 
2255
        TALLOC_CTX *mem_ctx;
 
2256
 
 
2257
        if (state->out_mem_ctx) {
 
2258
                mem_ctx = state->out_mem_ctx;
 
2259
        } else {
 
2260
                mem_ctx = state;
 
2261
        }
 
2262
 
 
2263
        status = dcerpc_eventlog6_EvtRpcMessageRender_r_recv(subreq, mem_ctx);
 
2264
        TALLOC_FREE(subreq);
 
2265
        if (!NT_STATUS_IS_OK(status)) {
 
2266
                tevent_req_nterror(req, status);
 
2267
                return;
 
2268
        }
 
2269
 
 
2270
        /* Copy out parameters */
 
2271
        *state->orig.out.actualSizeString = *state->tmp.out.actualSizeString;
 
2272
        *state->orig.out.neededSizeString = *state->tmp.out.neededSizeString;
 
2273
        *state->orig.out.string = *state->tmp.out.string;
 
2274
        *state->orig.out.error = *state->tmp.out.error;
 
2275
 
 
2276
        /* Copy result */
 
2277
        state->orig.out.result = state->tmp.out.result;
 
2278
 
 
2279
        /* Reset temporary structure */
 
2280
        ZERO_STRUCT(state->tmp);
 
2281
 
 
2282
        tevent_req_done(req);
 
2283
}
 
2284
 
 
2285
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRender_recv(struct tevent_req *req,
 
2286
                                                   TALLOC_CTX *mem_ctx,
 
2287
                                                   WERROR *result)
 
2288
{
 
2289
        struct dcerpc_eventlog6_EvtRpcMessageRender_state *state = tevent_req_data(
 
2290
                req, struct dcerpc_eventlog6_EvtRpcMessageRender_state);
 
2291
        NTSTATUS status;
 
2292
 
 
2293
        if (tevent_req_is_nterror(req, &status)) {
 
2294
                tevent_req_received(req);
 
2295
                return status;
 
2296
        }
 
2297
 
 
2298
        /* Steal possible out parameters to the callers context */
 
2299
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2300
 
 
2301
        /* Return result */
 
2302
        *result = state->orig.out.result;
 
2303
 
 
2304
        tevent_req_received(req);
 
2305
        return NT_STATUS_OK;
 
2306
}
 
2307
 
 
2308
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRender(struct dcerpc_binding_handle *h,
 
2309
                                              TALLOC_CTX *mem_ctx,
 
2310
                                              struct policy_handle *_pubCfgObj /* [in] [ref] */,
 
2311
                                              uint32_t _sizeEventId /* [in] [range(1,MAX_RPC_EVENT_ID_SIZE)] */,
 
2312
                                              uint8_t *_eventId /* [in] [ref,size_is(sizeEventId)] */,
 
2313
                                              uint32_t _messageId /* [in]  */,
 
2314
                                              struct eventlog6_EvtRpcVariantList *_values /* [in] [ref] */,
 
2315
                                              uint32_t _flags /* [in]  */,
 
2316
                                              uint32_t _maxSizeString /* [in]  */,
 
2317
                                              uint32_t *_actualSizeString /* [out] [ref] */,
 
2318
                                              uint32_t *_neededSizeString /* [out] [ref] */,
 
2319
                                              uint8_t **_string /* [out] [ref,range(0,MAX_RPC_RENDERED_STRING_SIZE),size_is(,*actualSizeString)] */,
 
2320
                                              struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
2321
                                              WERROR *result)
 
2322
{
 
2323
        struct eventlog6_EvtRpcMessageRender r;
 
2324
        NTSTATUS status;
 
2325
 
 
2326
        /* In parameters */
 
2327
        r.in.pubCfgObj = _pubCfgObj;
 
2328
        r.in.sizeEventId = _sizeEventId;
 
2329
        r.in.eventId = _eventId;
 
2330
        r.in.messageId = _messageId;
 
2331
        r.in.values = _values;
 
2332
        r.in.flags = _flags;
 
2333
        r.in.maxSizeString = _maxSizeString;
 
2334
 
 
2335
        status = dcerpc_eventlog6_EvtRpcMessageRender_r(h, mem_ctx, &r);
 
2336
        if (!NT_STATUS_IS_OK(status)) {
 
2337
                return status;
 
2338
        }
 
2339
 
 
2340
        /* Return variables */
 
2341
        *_actualSizeString = *r.out.actualSizeString;
 
2342
        *_neededSizeString = *r.out.neededSizeString;
 
2343
        *_string = *r.out.string;
 
2344
        *_error = *r.out.error;
 
2345
 
 
2346
        /* Return result */
 
2347
        *result = r.out.result;
 
2348
 
 
2349
        return NT_STATUS_OK;
 
2350
}
 
2351
 
 
2352
struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_state {
 
2353
        TALLOC_CTX *out_mem_ctx;
 
2354
};
 
2355
 
 
2356
static void dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_done(struct tevent_req *subreq);
 
2357
 
 
2358
struct tevent_req *dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_send(TALLOC_CTX *mem_ctx,
 
2359
        struct tevent_context *ev,
 
2360
        struct dcerpc_binding_handle *h,
 
2361
        struct eventlog6_EvtRpcMessageRenderDefault *r)
 
2362
{
 
2363
        struct tevent_req *req;
 
2364
        struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_state *state;
 
2365
        struct tevent_req *subreq;
 
2366
 
 
2367
        req = tevent_req_create(mem_ctx, &state,
 
2368
                                struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_state);
 
2369
        if (req == NULL) {
 
2370
                return NULL;
 
2371
        }
 
2372
 
 
2373
        state->out_mem_ctx = talloc_new(state);
 
2374
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2375
                return tevent_req_post(req, ev);
 
2376
        }
 
2377
 
 
2378
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
2379
                        NULL, &ndr_table_eventlog6,
 
2380
                        NDR_EVENTLOG6_EVTRPCMESSAGERENDERDEFAULT, state->out_mem_ctx, r);
 
2381
        if (tevent_req_nomem(subreq, req)) {
 
2382
                return tevent_req_post(req, ev);
 
2383
        }
 
2384
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_done, req);
 
2385
 
 
2386
        return req;
 
2387
}
 
2388
 
 
2389
static void dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_done(struct tevent_req *subreq)
 
2390
{
 
2391
        struct tevent_req *req =
 
2392
                tevent_req_callback_data(subreq,
 
2393
                struct tevent_req);
 
2394
        NTSTATUS status;
 
2395
 
 
2396
        status = dcerpc_binding_handle_call_recv(subreq);
 
2397
        if (!NT_STATUS_IS_OK(status)) {
 
2398
                tevent_req_nterror(req, status);
 
2399
                return;
 
2400
        }
 
2401
 
 
2402
        tevent_req_done(req);
 
2403
}
 
2404
 
 
2405
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
2406
{
 
2407
        struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_state *state =
 
2408
                tevent_req_data(req,
 
2409
                struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_state);
 
2410
        NTSTATUS status;
 
2411
 
 
2412
        if (tevent_req_is_nterror(req, &status)) {
 
2413
                tevent_req_received(req);
 
2414
                return status;
 
2415
        }
 
2416
 
 
2417
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2418
 
 
2419
        tevent_req_received(req);
 
2420
        return NT_STATUS_OK;
 
2421
}
 
2422
 
 
2423
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRenderDefault_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcMessageRenderDefault *r)
 
2424
{
 
2425
        NTSTATUS status;
 
2426
 
 
2427
        status = dcerpc_binding_handle_call(h,
 
2428
                        NULL, &ndr_table_eventlog6,
 
2429
                        NDR_EVENTLOG6_EVTRPCMESSAGERENDERDEFAULT, mem_ctx, r);
 
2430
 
 
2431
        return status;
 
2432
}
 
2433
 
 
2434
struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state {
 
2435
        struct eventlog6_EvtRpcMessageRenderDefault orig;
 
2436
        struct eventlog6_EvtRpcMessageRenderDefault tmp;
 
2437
        TALLOC_CTX *out_mem_ctx;
 
2438
};
 
2439
 
 
2440
static void dcerpc_eventlog6_EvtRpcMessageRenderDefault_done(struct tevent_req *subreq);
 
2441
 
 
2442
struct tevent_req *dcerpc_eventlog6_EvtRpcMessageRenderDefault_send(TALLOC_CTX *mem_ctx,
 
2443
                                                                    struct tevent_context *ev,
 
2444
                                                                    struct dcerpc_binding_handle *h,
 
2445
                                                                    uint32_t _sizeEventId /* [in] [range(1,MAX_RPC_EVENT_ID_SIZE)] */,
 
2446
                                                                    uint8_t *_eventId /* [in] [ref,size_is(sizeEventId)] */,
 
2447
                                                                    uint32_t _messageId /* [in]  */,
 
2448
                                                                    struct eventlog6_EvtRpcVariantList *_values /* [in] [ref] */,
 
2449
                                                                    uint32_t _flags /* [in]  */,
 
2450
                                                                    uint32_t _maxSizeString /* [in]  */,
 
2451
                                                                    uint32_t *_actualSizeString /* [out] [ref] */,
 
2452
                                                                    uint32_t *_neededSizeString /* [out] [ref] */,
 
2453
                                                                    uint8_t **_string /* [out] [ref,range(0,MAX_RPC_RENDERED_STRING_SIZE),size_is(,*actualSizeString)] */,
 
2454
                                                                    struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
2455
{
 
2456
        struct tevent_req *req;
 
2457
        struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state *state;
 
2458
        struct tevent_req *subreq;
 
2459
 
 
2460
        req = tevent_req_create(mem_ctx, &state,
 
2461
                                struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state);
 
2462
        if (req == NULL) {
 
2463
                return NULL;
 
2464
        }
 
2465
        state->out_mem_ctx = NULL;
 
2466
 
 
2467
        /* In parameters */
 
2468
        state->orig.in.sizeEventId = _sizeEventId;
 
2469
        state->orig.in.eventId = _eventId;
 
2470
        state->orig.in.messageId = _messageId;
 
2471
        state->orig.in.values = _values;
 
2472
        state->orig.in.flags = _flags;
 
2473
        state->orig.in.maxSizeString = _maxSizeString;
 
2474
 
 
2475
        /* Out parameters */
 
2476
        state->orig.out.actualSizeString = _actualSizeString;
 
2477
        state->orig.out.neededSizeString = _neededSizeString;
 
2478
        state->orig.out.string = _string;
 
2479
        state->orig.out.error = _error;
 
2480
 
 
2481
        /* Result */
 
2482
        ZERO_STRUCT(state->orig.out.result);
 
2483
 
 
2484
        state->out_mem_ctx = talloc_named_const(state, 0,
 
2485
                             "dcerpc_eventlog6_EvtRpcMessageRenderDefault_out_memory");
 
2486
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2487
                return tevent_req_post(req, ev);
 
2488
        }
 
2489
 
 
2490
        /* make a temporary copy, that we pass to the dispatch function */
 
2491
        state->tmp = state->orig;
 
2492
 
 
2493
        subreq = dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_send(state, ev, h, &state->tmp);
 
2494
        if (tevent_req_nomem(subreq, req)) {
 
2495
                return tevent_req_post(req, ev);
 
2496
        }
 
2497
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcMessageRenderDefault_done, req);
 
2498
        return req;
 
2499
}
 
2500
 
 
2501
static void dcerpc_eventlog6_EvtRpcMessageRenderDefault_done(struct tevent_req *subreq)
 
2502
{
 
2503
        struct tevent_req *req = tevent_req_callback_data(
 
2504
                subreq, struct tevent_req);
 
2505
        struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state *state = tevent_req_data(
 
2506
                req, struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state);
 
2507
        NTSTATUS status;
 
2508
        TALLOC_CTX *mem_ctx;
 
2509
 
 
2510
        if (state->out_mem_ctx) {
 
2511
                mem_ctx = state->out_mem_ctx;
 
2512
        } else {
 
2513
                mem_ctx = state;
 
2514
        }
 
2515
 
 
2516
        status = dcerpc_eventlog6_EvtRpcMessageRenderDefault_r_recv(subreq, mem_ctx);
 
2517
        TALLOC_FREE(subreq);
 
2518
        if (!NT_STATUS_IS_OK(status)) {
 
2519
                tevent_req_nterror(req, status);
 
2520
                return;
 
2521
        }
 
2522
 
 
2523
        /* Copy out parameters */
 
2524
        *state->orig.out.actualSizeString = *state->tmp.out.actualSizeString;
 
2525
        *state->orig.out.neededSizeString = *state->tmp.out.neededSizeString;
 
2526
        *state->orig.out.string = *state->tmp.out.string;
 
2527
        *state->orig.out.error = *state->tmp.out.error;
 
2528
 
 
2529
        /* Copy result */
 
2530
        state->orig.out.result = state->tmp.out.result;
 
2531
 
 
2532
        /* Reset temporary structure */
 
2533
        ZERO_STRUCT(state->tmp);
 
2534
 
 
2535
        tevent_req_done(req);
 
2536
}
 
2537
 
 
2538
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRenderDefault_recv(struct tevent_req *req,
 
2539
                                                          TALLOC_CTX *mem_ctx,
 
2540
                                                          WERROR *result)
 
2541
{
 
2542
        struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state *state = tevent_req_data(
 
2543
                req, struct dcerpc_eventlog6_EvtRpcMessageRenderDefault_state);
 
2544
        NTSTATUS status;
 
2545
 
 
2546
        if (tevent_req_is_nterror(req, &status)) {
 
2547
                tevent_req_received(req);
 
2548
                return status;
 
2549
        }
 
2550
 
 
2551
        /* Steal possible out parameters to the callers context */
 
2552
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2553
 
 
2554
        /* Return result */
 
2555
        *result = state->orig.out.result;
 
2556
 
 
2557
        tevent_req_received(req);
 
2558
        return NT_STATUS_OK;
 
2559
}
 
2560
 
 
2561
NTSTATUS dcerpc_eventlog6_EvtRpcMessageRenderDefault(struct dcerpc_binding_handle *h,
 
2562
                                                     TALLOC_CTX *mem_ctx,
 
2563
                                                     uint32_t _sizeEventId /* [in] [range(1,MAX_RPC_EVENT_ID_SIZE)] */,
 
2564
                                                     uint8_t *_eventId /* [in] [ref,size_is(sizeEventId)] */,
 
2565
                                                     uint32_t _messageId /* [in]  */,
 
2566
                                                     struct eventlog6_EvtRpcVariantList *_values /* [in] [ref] */,
 
2567
                                                     uint32_t _flags /* [in]  */,
 
2568
                                                     uint32_t _maxSizeString /* [in]  */,
 
2569
                                                     uint32_t *_actualSizeString /* [out] [ref] */,
 
2570
                                                     uint32_t *_neededSizeString /* [out] [ref] */,
 
2571
                                                     uint8_t **_string /* [out] [ref,range(0,MAX_RPC_RENDERED_STRING_SIZE),size_is(,*actualSizeString)] */,
 
2572
                                                     struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
2573
                                                     WERROR *result)
 
2574
{
 
2575
        struct eventlog6_EvtRpcMessageRenderDefault r;
 
2576
        NTSTATUS status;
 
2577
 
 
2578
        /* In parameters */
 
2579
        r.in.sizeEventId = _sizeEventId;
 
2580
        r.in.eventId = _eventId;
 
2581
        r.in.messageId = _messageId;
 
2582
        r.in.values = _values;
 
2583
        r.in.flags = _flags;
 
2584
        r.in.maxSizeString = _maxSizeString;
 
2585
 
 
2586
        status = dcerpc_eventlog6_EvtRpcMessageRenderDefault_r(h, mem_ctx, &r);
 
2587
        if (!NT_STATUS_IS_OK(status)) {
 
2588
                return status;
 
2589
        }
 
2590
 
 
2591
        /* Return variables */
 
2592
        *_actualSizeString = *r.out.actualSizeString;
 
2593
        *_neededSizeString = *r.out.neededSizeString;
 
2594
        *_string = *r.out.string;
 
2595
        *_error = *r.out.error;
 
2596
 
 
2597
        /* Return result */
 
2598
        *result = r.out.result;
 
2599
 
 
2600
        return NT_STATUS_OK;
 
2601
}
 
2602
 
 
2603
struct dcerpc_eventlog6_EvtRpcQueryNext_r_state {
 
2604
        TALLOC_CTX *out_mem_ctx;
 
2605
};
 
2606
 
 
2607
static void dcerpc_eventlog6_EvtRpcQueryNext_r_done(struct tevent_req *subreq);
 
2608
 
 
2609
struct tevent_req *dcerpc_eventlog6_EvtRpcQueryNext_r_send(TALLOC_CTX *mem_ctx,
 
2610
        struct tevent_context *ev,
 
2611
        struct dcerpc_binding_handle *h,
 
2612
        struct eventlog6_EvtRpcQueryNext *r)
 
2613
{
 
2614
        struct tevent_req *req;
 
2615
        struct dcerpc_eventlog6_EvtRpcQueryNext_r_state *state;
 
2616
        struct tevent_req *subreq;
 
2617
 
 
2618
        req = tevent_req_create(mem_ctx, &state,
 
2619
                                struct dcerpc_eventlog6_EvtRpcQueryNext_r_state);
 
2620
        if (req == NULL) {
 
2621
                return NULL;
 
2622
        }
 
2623
 
 
2624
        state->out_mem_ctx = talloc_new(state);
 
2625
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2626
                return tevent_req_post(req, ev);
 
2627
        }
 
2628
 
 
2629
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
2630
                        NULL, &ndr_table_eventlog6,
 
2631
                        NDR_EVENTLOG6_EVTRPCQUERYNEXT, state->out_mem_ctx, r);
 
2632
        if (tevent_req_nomem(subreq, req)) {
 
2633
                return tevent_req_post(req, ev);
 
2634
        }
 
2635
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcQueryNext_r_done, req);
 
2636
 
 
2637
        return req;
 
2638
}
 
2639
 
 
2640
static void dcerpc_eventlog6_EvtRpcQueryNext_r_done(struct tevent_req *subreq)
 
2641
{
 
2642
        struct tevent_req *req =
 
2643
                tevent_req_callback_data(subreq,
 
2644
                struct tevent_req);
 
2645
        NTSTATUS status;
 
2646
 
 
2647
        status = dcerpc_binding_handle_call_recv(subreq);
 
2648
        if (!NT_STATUS_IS_OK(status)) {
 
2649
                tevent_req_nterror(req, status);
 
2650
                return;
 
2651
        }
 
2652
 
 
2653
        tevent_req_done(req);
 
2654
}
 
2655
 
 
2656
NTSTATUS dcerpc_eventlog6_EvtRpcQueryNext_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
2657
{
 
2658
        struct dcerpc_eventlog6_EvtRpcQueryNext_r_state *state =
 
2659
                tevent_req_data(req,
 
2660
                struct dcerpc_eventlog6_EvtRpcQueryNext_r_state);
 
2661
        NTSTATUS status;
 
2662
 
 
2663
        if (tevent_req_is_nterror(req, &status)) {
 
2664
                tevent_req_received(req);
 
2665
                return status;
 
2666
        }
 
2667
 
 
2668
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2669
 
 
2670
        tevent_req_received(req);
 
2671
        return NT_STATUS_OK;
 
2672
}
 
2673
 
 
2674
NTSTATUS dcerpc_eventlog6_EvtRpcQueryNext_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcQueryNext *r)
 
2675
{
 
2676
        NTSTATUS status;
 
2677
 
 
2678
        status = dcerpc_binding_handle_call(h,
 
2679
                        NULL, &ndr_table_eventlog6,
 
2680
                        NDR_EVENTLOG6_EVTRPCQUERYNEXT, mem_ctx, r);
 
2681
 
 
2682
        return status;
 
2683
}
 
2684
 
 
2685
struct dcerpc_eventlog6_EvtRpcQueryNext_state {
 
2686
        struct eventlog6_EvtRpcQueryNext orig;
 
2687
        struct eventlog6_EvtRpcQueryNext tmp;
 
2688
        TALLOC_CTX *out_mem_ctx;
 
2689
};
 
2690
 
 
2691
static void dcerpc_eventlog6_EvtRpcQueryNext_done(struct tevent_req *subreq);
 
2692
 
 
2693
struct tevent_req *dcerpc_eventlog6_EvtRpcQueryNext_send(TALLOC_CTX *mem_ctx,
 
2694
                                                         struct tevent_context *ev,
 
2695
                                                         struct dcerpc_binding_handle *h,
 
2696
                                                         struct policy_handle *_logQuery /* [in] [ref] */,
 
2697
                                                         uint32_t _numRequestedRecords /* [in]  */,
 
2698
                                                         uint32_t _timeOutEnd /* [in]  */,
 
2699
                                                         uint32_t _flags /* [in]  */,
 
2700
                                                         uint32_t *_numActualRecords /* [out] [ref] */,
 
2701
                                                         uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
2702
                                                         uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
2703
                                                         uint32_t *_resultBufferSize /* [out] [ref] */,
 
2704
                                                         uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */)
 
2705
{
 
2706
        struct tevent_req *req;
 
2707
        struct dcerpc_eventlog6_EvtRpcQueryNext_state *state;
 
2708
        struct tevent_req *subreq;
 
2709
 
 
2710
        req = tevent_req_create(mem_ctx, &state,
 
2711
                                struct dcerpc_eventlog6_EvtRpcQueryNext_state);
 
2712
        if (req == NULL) {
 
2713
                return NULL;
 
2714
        }
 
2715
        state->out_mem_ctx = NULL;
 
2716
 
 
2717
        /* In parameters */
 
2718
        state->orig.in.logQuery = _logQuery;
 
2719
        state->orig.in.numRequestedRecords = _numRequestedRecords;
 
2720
        state->orig.in.timeOutEnd = _timeOutEnd;
 
2721
        state->orig.in.flags = _flags;
 
2722
 
 
2723
        /* Out parameters */
 
2724
        state->orig.out.numActualRecords = _numActualRecords;
 
2725
        state->orig.out.eventDataIndices = _eventDataIndices;
 
2726
        state->orig.out.eventDataSizes = _eventDataSizes;
 
2727
        state->orig.out.resultBufferSize = _resultBufferSize;
 
2728
        state->orig.out.resultBuffer = _resultBuffer;
 
2729
 
 
2730
        /* Result */
 
2731
        ZERO_STRUCT(state->orig.out.result);
 
2732
 
 
2733
        state->out_mem_ctx = talloc_named_const(state, 0,
 
2734
                             "dcerpc_eventlog6_EvtRpcQueryNext_out_memory");
 
2735
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2736
                return tevent_req_post(req, ev);
 
2737
        }
 
2738
 
 
2739
        /* make a temporary copy, that we pass to the dispatch function */
 
2740
        state->tmp = state->orig;
 
2741
 
 
2742
        subreq = dcerpc_eventlog6_EvtRpcQueryNext_r_send(state, ev, h, &state->tmp);
 
2743
        if (tevent_req_nomem(subreq, req)) {
 
2744
                return tevent_req_post(req, ev);
 
2745
        }
 
2746
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcQueryNext_done, req);
 
2747
        return req;
 
2748
}
 
2749
 
 
2750
static void dcerpc_eventlog6_EvtRpcQueryNext_done(struct tevent_req *subreq)
 
2751
{
 
2752
        struct tevent_req *req = tevent_req_callback_data(
 
2753
                subreq, struct tevent_req);
 
2754
        struct dcerpc_eventlog6_EvtRpcQueryNext_state *state = tevent_req_data(
 
2755
                req, struct dcerpc_eventlog6_EvtRpcQueryNext_state);
 
2756
        NTSTATUS status;
 
2757
        TALLOC_CTX *mem_ctx;
 
2758
 
 
2759
        if (state->out_mem_ctx) {
 
2760
                mem_ctx = state->out_mem_ctx;
 
2761
        } else {
 
2762
                mem_ctx = state;
 
2763
        }
 
2764
 
 
2765
        status = dcerpc_eventlog6_EvtRpcQueryNext_r_recv(subreq, mem_ctx);
 
2766
        TALLOC_FREE(subreq);
 
2767
        if (!NT_STATUS_IS_OK(status)) {
 
2768
                tevent_req_nterror(req, status);
 
2769
                return;
 
2770
        }
 
2771
 
 
2772
        /* Copy out parameters */
 
2773
        *state->orig.out.numActualRecords = *state->tmp.out.numActualRecords;
 
2774
        *state->orig.out.eventDataIndices = *state->tmp.out.eventDataIndices;
 
2775
        *state->orig.out.eventDataSizes = *state->tmp.out.eventDataSizes;
 
2776
        *state->orig.out.resultBufferSize = *state->tmp.out.resultBufferSize;
 
2777
        *state->orig.out.resultBuffer = *state->tmp.out.resultBuffer;
 
2778
 
 
2779
        /* Copy result */
 
2780
        state->orig.out.result = state->tmp.out.result;
 
2781
 
 
2782
        /* Reset temporary structure */
 
2783
        ZERO_STRUCT(state->tmp);
 
2784
 
 
2785
        tevent_req_done(req);
 
2786
}
 
2787
 
 
2788
NTSTATUS dcerpc_eventlog6_EvtRpcQueryNext_recv(struct tevent_req *req,
 
2789
                                               TALLOC_CTX *mem_ctx,
 
2790
                                               WERROR *result)
 
2791
{
 
2792
        struct dcerpc_eventlog6_EvtRpcQueryNext_state *state = tevent_req_data(
 
2793
                req, struct dcerpc_eventlog6_EvtRpcQueryNext_state);
 
2794
        NTSTATUS status;
 
2795
 
 
2796
        if (tevent_req_is_nterror(req, &status)) {
 
2797
                tevent_req_received(req);
 
2798
                return status;
 
2799
        }
 
2800
 
 
2801
        /* Steal possible out parameters to the callers context */
 
2802
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2803
 
 
2804
        /* Return result */
 
2805
        *result = state->orig.out.result;
 
2806
 
 
2807
        tevent_req_received(req);
 
2808
        return NT_STATUS_OK;
 
2809
}
 
2810
 
 
2811
NTSTATUS dcerpc_eventlog6_EvtRpcQueryNext(struct dcerpc_binding_handle *h,
 
2812
                                          TALLOC_CTX *mem_ctx,
 
2813
                                          struct policy_handle *_logQuery /* [in] [ref] */,
 
2814
                                          uint32_t _numRequestedRecords /* [in]  */,
 
2815
                                          uint32_t _timeOutEnd /* [in]  */,
 
2816
                                          uint32_t _flags /* [in]  */,
 
2817
                                          uint32_t *_numActualRecords /* [out] [ref] */,
 
2818
                                          uint32_t **_eventDataIndices /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
2819
                                          uint32_t **_eventDataSizes /* [out] [ref,range(0,MAX_RPC_RECORD_COUNT),size_is(,*numActualRecords)] */,
 
2820
                                          uint32_t *_resultBufferSize /* [out] [ref] */,
 
2821
                                          uint8_t **_resultBuffer /* [out] [ref,range(0,MAX_RPC_BATCH_SIZE),size_is(,*resultBufferSize)] */,
 
2822
                                          WERROR *result)
 
2823
{
 
2824
        struct eventlog6_EvtRpcQueryNext r;
 
2825
        NTSTATUS status;
 
2826
 
 
2827
        /* In parameters */
 
2828
        r.in.logQuery = _logQuery;
 
2829
        r.in.numRequestedRecords = _numRequestedRecords;
 
2830
        r.in.timeOutEnd = _timeOutEnd;
 
2831
        r.in.flags = _flags;
 
2832
 
 
2833
        status = dcerpc_eventlog6_EvtRpcQueryNext_r(h, mem_ctx, &r);
 
2834
        if (!NT_STATUS_IS_OK(status)) {
 
2835
                return status;
 
2836
        }
 
2837
 
 
2838
        /* Return variables */
 
2839
        *_numActualRecords = *r.out.numActualRecords;
 
2840
        *_eventDataIndices = *r.out.eventDataIndices;
 
2841
        *_eventDataSizes = *r.out.eventDataSizes;
 
2842
        *_resultBufferSize = *r.out.resultBufferSize;
 
2843
        *_resultBuffer = *r.out.resultBuffer;
 
2844
 
 
2845
        /* Return result */
 
2846
        *result = r.out.result;
 
2847
 
 
2848
        return NT_STATUS_OK;
 
2849
}
 
2850
 
 
2851
struct dcerpc_eventlog6_EvtRpcQuerySeek_r_state {
 
2852
        TALLOC_CTX *out_mem_ctx;
 
2853
};
 
2854
 
 
2855
static void dcerpc_eventlog6_EvtRpcQuerySeek_r_done(struct tevent_req *subreq);
 
2856
 
 
2857
struct tevent_req *dcerpc_eventlog6_EvtRpcQuerySeek_r_send(TALLOC_CTX *mem_ctx,
 
2858
        struct tevent_context *ev,
 
2859
        struct dcerpc_binding_handle *h,
 
2860
        struct eventlog6_EvtRpcQuerySeek *r)
 
2861
{
 
2862
        struct tevent_req *req;
 
2863
        struct dcerpc_eventlog6_EvtRpcQuerySeek_r_state *state;
 
2864
        struct tevent_req *subreq;
 
2865
 
 
2866
        req = tevent_req_create(mem_ctx, &state,
 
2867
                                struct dcerpc_eventlog6_EvtRpcQuerySeek_r_state);
 
2868
        if (req == NULL) {
 
2869
                return NULL;
 
2870
        }
 
2871
 
 
2872
        state->out_mem_ctx = talloc_new(state);
 
2873
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2874
                return tevent_req_post(req, ev);
 
2875
        }
 
2876
 
 
2877
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
2878
                        NULL, &ndr_table_eventlog6,
 
2879
                        NDR_EVENTLOG6_EVTRPCQUERYSEEK, state->out_mem_ctx, r);
 
2880
        if (tevent_req_nomem(subreq, req)) {
 
2881
                return tevent_req_post(req, ev);
 
2882
        }
 
2883
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcQuerySeek_r_done, req);
 
2884
 
 
2885
        return req;
 
2886
}
 
2887
 
 
2888
static void dcerpc_eventlog6_EvtRpcQuerySeek_r_done(struct tevent_req *subreq)
 
2889
{
 
2890
        struct tevent_req *req =
 
2891
                tevent_req_callback_data(subreq,
 
2892
                struct tevent_req);
 
2893
        NTSTATUS status;
 
2894
 
 
2895
        status = dcerpc_binding_handle_call_recv(subreq);
 
2896
        if (!NT_STATUS_IS_OK(status)) {
 
2897
                tevent_req_nterror(req, status);
 
2898
                return;
 
2899
        }
 
2900
 
 
2901
        tevent_req_done(req);
 
2902
}
 
2903
 
 
2904
NTSTATUS dcerpc_eventlog6_EvtRpcQuerySeek_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
2905
{
 
2906
        struct dcerpc_eventlog6_EvtRpcQuerySeek_r_state *state =
 
2907
                tevent_req_data(req,
 
2908
                struct dcerpc_eventlog6_EvtRpcQuerySeek_r_state);
 
2909
        NTSTATUS status;
 
2910
 
 
2911
        if (tevent_req_is_nterror(req, &status)) {
 
2912
                tevent_req_received(req);
 
2913
                return status;
 
2914
        }
 
2915
 
 
2916
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2917
 
 
2918
        tevent_req_received(req);
 
2919
        return NT_STATUS_OK;
 
2920
}
 
2921
 
 
2922
NTSTATUS dcerpc_eventlog6_EvtRpcQuerySeek_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcQuerySeek *r)
 
2923
{
 
2924
        NTSTATUS status;
 
2925
 
 
2926
        status = dcerpc_binding_handle_call(h,
 
2927
                        NULL, &ndr_table_eventlog6,
 
2928
                        NDR_EVENTLOG6_EVTRPCQUERYSEEK, mem_ctx, r);
 
2929
 
 
2930
        return status;
 
2931
}
 
2932
 
 
2933
struct dcerpc_eventlog6_EvtRpcQuerySeek_state {
 
2934
        struct eventlog6_EvtRpcQuerySeek orig;
 
2935
        struct eventlog6_EvtRpcQuerySeek tmp;
 
2936
        TALLOC_CTX *out_mem_ctx;
 
2937
};
 
2938
 
 
2939
static void dcerpc_eventlog6_EvtRpcQuerySeek_done(struct tevent_req *subreq);
 
2940
 
 
2941
struct tevent_req *dcerpc_eventlog6_EvtRpcQuerySeek_send(TALLOC_CTX *mem_ctx,
 
2942
                                                         struct tevent_context *ev,
 
2943
                                                         struct dcerpc_binding_handle *h,
 
2944
                                                         struct policy_handle *_logQuery /* [in] [ref] */,
 
2945
                                                         uint64_t _pos /* [in]  */,
 
2946
                                                         const char *_bookmarkXml /* [in] [unique,range(0,MAX_RPC_BOOKMARK_LENGTH),charset(UTF16)] */,
 
2947
                                                         uint32_t _timeOut /* [in]  */,
 
2948
                                                         uint32_t _flags /* [in]  */,
 
2949
                                                         struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
2950
{
 
2951
        struct tevent_req *req;
 
2952
        struct dcerpc_eventlog6_EvtRpcQuerySeek_state *state;
 
2953
        struct tevent_req *subreq;
 
2954
 
 
2955
        req = tevent_req_create(mem_ctx, &state,
 
2956
                                struct dcerpc_eventlog6_EvtRpcQuerySeek_state);
 
2957
        if (req == NULL) {
 
2958
                return NULL;
 
2959
        }
 
2960
        state->out_mem_ctx = NULL;
 
2961
 
 
2962
        /* In parameters */
 
2963
        state->orig.in.logQuery = _logQuery;
 
2964
        state->orig.in.pos = _pos;
 
2965
        state->orig.in.bookmarkXml = _bookmarkXml;
 
2966
        state->orig.in.timeOut = _timeOut;
 
2967
        state->orig.in.flags = _flags;
 
2968
 
 
2969
        /* Out parameters */
 
2970
        state->orig.out.error = _error;
 
2971
 
 
2972
        /* Result */
 
2973
        ZERO_STRUCT(state->orig.out.result);
 
2974
 
 
2975
        state->out_mem_ctx = talloc_named_const(state, 0,
 
2976
                             "dcerpc_eventlog6_EvtRpcQuerySeek_out_memory");
 
2977
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2978
                return tevent_req_post(req, ev);
 
2979
        }
 
2980
 
 
2981
        /* make a temporary copy, that we pass to the dispatch function */
 
2982
        state->tmp = state->orig;
 
2983
 
 
2984
        subreq = dcerpc_eventlog6_EvtRpcQuerySeek_r_send(state, ev, h, &state->tmp);
 
2985
        if (tevent_req_nomem(subreq, req)) {
 
2986
                return tevent_req_post(req, ev);
 
2987
        }
 
2988
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcQuerySeek_done, req);
 
2989
        return req;
 
2990
}
 
2991
 
 
2992
static void dcerpc_eventlog6_EvtRpcQuerySeek_done(struct tevent_req *subreq)
 
2993
{
 
2994
        struct tevent_req *req = tevent_req_callback_data(
 
2995
                subreq, struct tevent_req);
 
2996
        struct dcerpc_eventlog6_EvtRpcQuerySeek_state *state = tevent_req_data(
 
2997
                req, struct dcerpc_eventlog6_EvtRpcQuerySeek_state);
 
2998
        NTSTATUS status;
 
2999
        TALLOC_CTX *mem_ctx;
 
3000
 
 
3001
        if (state->out_mem_ctx) {
 
3002
                mem_ctx = state->out_mem_ctx;
 
3003
        } else {
 
3004
                mem_ctx = state;
 
3005
        }
 
3006
 
 
3007
        status = dcerpc_eventlog6_EvtRpcQuerySeek_r_recv(subreq, mem_ctx);
 
3008
        TALLOC_FREE(subreq);
 
3009
        if (!NT_STATUS_IS_OK(status)) {
 
3010
                tevent_req_nterror(req, status);
 
3011
                return;
 
3012
        }
 
3013
 
 
3014
        /* Copy out parameters */
 
3015
        *state->orig.out.error = *state->tmp.out.error;
 
3016
 
 
3017
        /* Copy result */
 
3018
        state->orig.out.result = state->tmp.out.result;
 
3019
 
 
3020
        /* Reset temporary structure */
 
3021
        ZERO_STRUCT(state->tmp);
 
3022
 
 
3023
        tevent_req_done(req);
 
3024
}
 
3025
 
 
3026
NTSTATUS dcerpc_eventlog6_EvtRpcQuerySeek_recv(struct tevent_req *req,
 
3027
                                               TALLOC_CTX *mem_ctx,
 
3028
                                               WERROR *result)
 
3029
{
 
3030
        struct dcerpc_eventlog6_EvtRpcQuerySeek_state *state = tevent_req_data(
 
3031
                req, struct dcerpc_eventlog6_EvtRpcQuerySeek_state);
 
3032
        NTSTATUS status;
 
3033
 
 
3034
        if (tevent_req_is_nterror(req, &status)) {
 
3035
                tevent_req_received(req);
 
3036
                return status;
 
3037
        }
 
3038
 
 
3039
        /* Steal possible out parameters to the callers context */
 
3040
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3041
 
 
3042
        /* Return result */
 
3043
        *result = state->orig.out.result;
 
3044
 
 
3045
        tevent_req_received(req);
 
3046
        return NT_STATUS_OK;
 
3047
}
 
3048
 
 
3049
NTSTATUS dcerpc_eventlog6_EvtRpcQuerySeek(struct dcerpc_binding_handle *h,
 
3050
                                          TALLOC_CTX *mem_ctx,
 
3051
                                          struct policy_handle *_logQuery /* [in] [ref] */,
 
3052
                                          uint64_t _pos /* [in]  */,
 
3053
                                          const char *_bookmarkXml /* [in] [unique,range(0,MAX_RPC_BOOKMARK_LENGTH),charset(UTF16)] */,
 
3054
                                          uint32_t _timeOut /* [in]  */,
 
3055
                                          uint32_t _flags /* [in]  */,
 
3056
                                          struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
3057
                                          WERROR *result)
 
3058
{
 
3059
        struct eventlog6_EvtRpcQuerySeek r;
 
3060
        NTSTATUS status;
 
3061
 
 
3062
        /* In parameters */
 
3063
        r.in.logQuery = _logQuery;
 
3064
        r.in.pos = _pos;
 
3065
        r.in.bookmarkXml = _bookmarkXml;
 
3066
        r.in.timeOut = _timeOut;
 
3067
        r.in.flags = _flags;
 
3068
 
 
3069
        status = dcerpc_eventlog6_EvtRpcQuerySeek_r(h, mem_ctx, &r);
 
3070
        if (!NT_STATUS_IS_OK(status)) {
 
3071
                return status;
 
3072
        }
 
3073
 
 
3074
        /* Return variables */
 
3075
        *_error = *r.out.error;
 
3076
 
 
3077
        /* Return result */
 
3078
        *result = r.out.result;
 
3079
 
 
3080
        return NT_STATUS_OK;
 
3081
}
 
3082
 
 
3083
struct dcerpc_eventlog6_EvtRpcClose_r_state {
 
3084
        TALLOC_CTX *out_mem_ctx;
 
3085
};
 
3086
 
 
3087
static void dcerpc_eventlog6_EvtRpcClose_r_done(struct tevent_req *subreq);
 
3088
 
 
3089
struct tevent_req *dcerpc_eventlog6_EvtRpcClose_r_send(TALLOC_CTX *mem_ctx,
 
3090
        struct tevent_context *ev,
 
3091
        struct dcerpc_binding_handle *h,
 
3092
        struct eventlog6_EvtRpcClose *r)
 
3093
{
 
3094
        struct tevent_req *req;
 
3095
        struct dcerpc_eventlog6_EvtRpcClose_r_state *state;
 
3096
        struct tevent_req *subreq;
 
3097
 
 
3098
        req = tevent_req_create(mem_ctx, &state,
 
3099
                                struct dcerpc_eventlog6_EvtRpcClose_r_state);
 
3100
        if (req == NULL) {
 
3101
                return NULL;
 
3102
        }
 
3103
 
 
3104
        state->out_mem_ctx = talloc_new(state);
 
3105
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
3106
                return tevent_req_post(req, ev);
 
3107
        }
 
3108
 
 
3109
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
3110
                        NULL, &ndr_table_eventlog6,
 
3111
                        NDR_EVENTLOG6_EVTRPCCLOSE, state->out_mem_ctx, r);
 
3112
        if (tevent_req_nomem(subreq, req)) {
 
3113
                return tevent_req_post(req, ev);
 
3114
        }
 
3115
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcClose_r_done, req);
 
3116
 
 
3117
        return req;
 
3118
}
 
3119
 
 
3120
static void dcerpc_eventlog6_EvtRpcClose_r_done(struct tevent_req *subreq)
 
3121
{
 
3122
        struct tevent_req *req =
 
3123
                tevent_req_callback_data(subreq,
 
3124
                struct tevent_req);
 
3125
        NTSTATUS status;
 
3126
 
 
3127
        status = dcerpc_binding_handle_call_recv(subreq);
 
3128
        if (!NT_STATUS_IS_OK(status)) {
 
3129
                tevent_req_nterror(req, status);
 
3130
                return;
 
3131
        }
 
3132
 
 
3133
        tevent_req_done(req);
 
3134
}
 
3135
 
 
3136
NTSTATUS dcerpc_eventlog6_EvtRpcClose_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
3137
{
 
3138
        struct dcerpc_eventlog6_EvtRpcClose_r_state *state =
 
3139
                tevent_req_data(req,
 
3140
                struct dcerpc_eventlog6_EvtRpcClose_r_state);
 
3141
        NTSTATUS status;
 
3142
 
 
3143
        if (tevent_req_is_nterror(req, &status)) {
 
3144
                tevent_req_received(req);
 
3145
                return status;
 
3146
        }
 
3147
 
 
3148
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3149
 
 
3150
        tevent_req_received(req);
 
3151
        return NT_STATUS_OK;
 
3152
}
 
3153
 
 
3154
NTSTATUS dcerpc_eventlog6_EvtRpcClose_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcClose *r)
 
3155
{
 
3156
        NTSTATUS status;
 
3157
 
 
3158
        status = dcerpc_binding_handle_call(h,
 
3159
                        NULL, &ndr_table_eventlog6,
 
3160
                        NDR_EVENTLOG6_EVTRPCCLOSE, mem_ctx, r);
 
3161
 
 
3162
        return status;
 
3163
}
 
3164
 
 
3165
struct dcerpc_eventlog6_EvtRpcClose_state {
 
3166
        struct eventlog6_EvtRpcClose orig;
 
3167
        struct eventlog6_EvtRpcClose tmp;
 
3168
        TALLOC_CTX *out_mem_ctx;
 
3169
};
 
3170
 
 
3171
static void dcerpc_eventlog6_EvtRpcClose_done(struct tevent_req *subreq);
 
3172
 
 
3173
struct tevent_req *dcerpc_eventlog6_EvtRpcClose_send(TALLOC_CTX *mem_ctx,
 
3174
                                                     struct tevent_context *ev,
 
3175
                                                     struct dcerpc_binding_handle *h,
 
3176
                                                     struct policy_handle **_handle /* [in,out] [ref] */)
 
3177
{
 
3178
        struct tevent_req *req;
 
3179
        struct dcerpc_eventlog6_EvtRpcClose_state *state;
 
3180
        struct tevent_req *subreq;
 
3181
 
 
3182
        req = tevent_req_create(mem_ctx, &state,
 
3183
                                struct dcerpc_eventlog6_EvtRpcClose_state);
 
3184
        if (req == NULL) {
 
3185
                return NULL;
 
3186
        }
 
3187
        state->out_mem_ctx = NULL;
 
3188
 
 
3189
        /* In parameters */
 
3190
        state->orig.in.handle = _handle;
 
3191
 
 
3192
        /* Out parameters */
 
3193
        state->orig.out.handle = _handle;
 
3194
 
 
3195
        /* Result */
 
3196
        ZERO_STRUCT(state->orig.out.result);
 
3197
 
 
3198
        state->out_mem_ctx = talloc_named_const(state, 0,
 
3199
                             "dcerpc_eventlog6_EvtRpcClose_out_memory");
 
3200
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
3201
                return tevent_req_post(req, ev);
 
3202
        }
 
3203
 
 
3204
        /* make a temporary copy, that we pass to the dispatch function */
 
3205
        state->tmp = state->orig;
 
3206
 
 
3207
        subreq = dcerpc_eventlog6_EvtRpcClose_r_send(state, ev, h, &state->tmp);
 
3208
        if (tevent_req_nomem(subreq, req)) {
 
3209
                return tevent_req_post(req, ev);
 
3210
        }
 
3211
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcClose_done, req);
 
3212
        return req;
 
3213
}
 
3214
 
 
3215
static void dcerpc_eventlog6_EvtRpcClose_done(struct tevent_req *subreq)
 
3216
{
 
3217
        struct tevent_req *req = tevent_req_callback_data(
 
3218
                subreq, struct tevent_req);
 
3219
        struct dcerpc_eventlog6_EvtRpcClose_state *state = tevent_req_data(
 
3220
                req, struct dcerpc_eventlog6_EvtRpcClose_state);
 
3221
        NTSTATUS status;
 
3222
        TALLOC_CTX *mem_ctx;
 
3223
 
 
3224
        if (state->out_mem_ctx) {
 
3225
                mem_ctx = state->out_mem_ctx;
 
3226
        } else {
 
3227
                mem_ctx = state;
 
3228
        }
 
3229
 
 
3230
        status = dcerpc_eventlog6_EvtRpcClose_r_recv(subreq, mem_ctx);
 
3231
        TALLOC_FREE(subreq);
 
3232
        if (!NT_STATUS_IS_OK(status)) {
 
3233
                tevent_req_nterror(req, status);
 
3234
                return;
 
3235
        }
 
3236
 
 
3237
        /* Copy out parameters */
 
3238
        *state->orig.out.handle = *state->tmp.out.handle;
 
3239
 
 
3240
        /* Copy result */
 
3241
        state->orig.out.result = state->tmp.out.result;
 
3242
 
 
3243
        /* Reset temporary structure */
 
3244
        ZERO_STRUCT(state->tmp);
 
3245
 
 
3246
        tevent_req_done(req);
 
3247
}
 
3248
 
 
3249
NTSTATUS dcerpc_eventlog6_EvtRpcClose_recv(struct tevent_req *req,
 
3250
                                           TALLOC_CTX *mem_ctx,
 
3251
                                           WERROR *result)
 
3252
{
 
3253
        struct dcerpc_eventlog6_EvtRpcClose_state *state = tevent_req_data(
 
3254
                req, struct dcerpc_eventlog6_EvtRpcClose_state);
 
3255
        NTSTATUS status;
 
3256
 
 
3257
        if (tevent_req_is_nterror(req, &status)) {
 
3258
                tevent_req_received(req);
 
3259
                return status;
 
3260
        }
 
3261
 
 
3262
        /* Steal possible out parameters to the callers context */
 
3263
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3264
 
 
3265
        /* Return result */
 
3266
        *result = state->orig.out.result;
 
3267
 
 
3268
        tevent_req_received(req);
 
3269
        return NT_STATUS_OK;
 
3270
}
 
3271
 
 
3272
NTSTATUS dcerpc_eventlog6_EvtRpcClose(struct dcerpc_binding_handle *h,
 
3273
                                      TALLOC_CTX *mem_ctx,
 
3274
                                      struct policy_handle **_handle /* [in,out] [ref] */,
 
3275
                                      WERROR *result)
 
3276
{
 
3277
        struct eventlog6_EvtRpcClose r;
 
3278
        NTSTATUS status;
 
3279
 
 
3280
        /* In parameters */
 
3281
        r.in.handle = _handle;
 
3282
 
 
3283
        status = dcerpc_eventlog6_EvtRpcClose_r(h, mem_ctx, &r);
 
3284
        if (!NT_STATUS_IS_OK(status)) {
 
3285
                return status;
 
3286
        }
 
3287
 
 
3288
        /* Return variables */
 
3289
        *_handle = *r.out.handle;
 
3290
 
 
3291
        /* Return result */
 
3292
        *result = r.out.result;
 
3293
 
 
3294
        return NT_STATUS_OK;
 
3295
}
 
3296
 
 
3297
struct dcerpc_eventlog6_EvtRpcCancel_r_state {
 
3298
        TALLOC_CTX *out_mem_ctx;
 
3299
};
 
3300
 
 
3301
static void dcerpc_eventlog6_EvtRpcCancel_r_done(struct tevent_req *subreq);
 
3302
 
 
3303
struct tevent_req *dcerpc_eventlog6_EvtRpcCancel_r_send(TALLOC_CTX *mem_ctx,
 
3304
        struct tevent_context *ev,
 
3305
        struct dcerpc_binding_handle *h,
 
3306
        struct eventlog6_EvtRpcCancel *r)
 
3307
{
 
3308
        struct tevent_req *req;
 
3309
        struct dcerpc_eventlog6_EvtRpcCancel_r_state *state;
 
3310
        struct tevent_req *subreq;
 
3311
 
 
3312
        req = tevent_req_create(mem_ctx, &state,
 
3313
                                struct dcerpc_eventlog6_EvtRpcCancel_r_state);
 
3314
        if (req == NULL) {
 
3315
                return NULL;
 
3316
        }
 
3317
 
 
3318
        state->out_mem_ctx = NULL;
 
3319
 
 
3320
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
3321
                        NULL, &ndr_table_eventlog6,
 
3322
                        NDR_EVENTLOG6_EVTRPCCANCEL, state, r);
 
3323
        if (tevent_req_nomem(subreq, req)) {
 
3324
                return tevent_req_post(req, ev);
 
3325
        }
 
3326
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcCancel_r_done, req);
 
3327
 
 
3328
        return req;
 
3329
}
 
3330
 
 
3331
static void dcerpc_eventlog6_EvtRpcCancel_r_done(struct tevent_req *subreq)
 
3332
{
 
3333
        struct tevent_req *req =
 
3334
                tevent_req_callback_data(subreq,
 
3335
                struct tevent_req);
 
3336
        NTSTATUS status;
 
3337
 
 
3338
        status = dcerpc_binding_handle_call_recv(subreq);
 
3339
        if (!NT_STATUS_IS_OK(status)) {
 
3340
                tevent_req_nterror(req, status);
 
3341
                return;
 
3342
        }
 
3343
 
 
3344
        tevent_req_done(req);
 
3345
}
 
3346
 
 
3347
NTSTATUS dcerpc_eventlog6_EvtRpcCancel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
3348
{
 
3349
        struct dcerpc_eventlog6_EvtRpcCancel_r_state *state =
 
3350
                tevent_req_data(req,
 
3351
                struct dcerpc_eventlog6_EvtRpcCancel_r_state);
 
3352
        NTSTATUS status;
 
3353
 
 
3354
        if (tevent_req_is_nterror(req, &status)) {
 
3355
                tevent_req_received(req);
 
3356
                return status;
 
3357
        }
 
3358
 
 
3359
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3360
 
 
3361
        tevent_req_received(req);
 
3362
        return NT_STATUS_OK;
 
3363
}
 
3364
 
 
3365
NTSTATUS dcerpc_eventlog6_EvtRpcCancel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcCancel *r)
 
3366
{
 
3367
        NTSTATUS status;
 
3368
 
 
3369
        status = dcerpc_binding_handle_call(h,
 
3370
                        NULL, &ndr_table_eventlog6,
 
3371
                        NDR_EVENTLOG6_EVTRPCCANCEL, mem_ctx, r);
 
3372
 
 
3373
        return status;
 
3374
}
 
3375
 
 
3376
struct dcerpc_eventlog6_EvtRpcCancel_state {
 
3377
        struct eventlog6_EvtRpcCancel orig;
 
3378
        struct eventlog6_EvtRpcCancel tmp;
 
3379
        TALLOC_CTX *out_mem_ctx;
 
3380
};
 
3381
 
 
3382
static void dcerpc_eventlog6_EvtRpcCancel_done(struct tevent_req *subreq);
 
3383
 
 
3384
struct tevent_req *dcerpc_eventlog6_EvtRpcCancel_send(TALLOC_CTX *mem_ctx,
 
3385
                                                      struct tevent_context *ev,
 
3386
                                                      struct dcerpc_binding_handle *h,
 
3387
                                                      struct policy_handle *_handle /* [in] [ref] */)
 
3388
{
 
3389
        struct tevent_req *req;
 
3390
        struct dcerpc_eventlog6_EvtRpcCancel_state *state;
 
3391
        struct tevent_req *subreq;
 
3392
 
 
3393
        req = tevent_req_create(mem_ctx, &state,
 
3394
                                struct dcerpc_eventlog6_EvtRpcCancel_state);
 
3395
        if (req == NULL) {
 
3396
                return NULL;
 
3397
        }
 
3398
        state->out_mem_ctx = NULL;
 
3399
 
 
3400
        /* In parameters */
 
3401
        state->orig.in.handle = _handle;
 
3402
 
 
3403
        /* Out parameters */
 
3404
 
 
3405
        /* Result */
 
3406
        ZERO_STRUCT(state->orig.out.result);
 
3407
 
 
3408
        /* make a temporary copy, that we pass to the dispatch function */
 
3409
        state->tmp = state->orig;
 
3410
 
 
3411
        subreq = dcerpc_eventlog6_EvtRpcCancel_r_send(state, ev, h, &state->tmp);
 
3412
        if (tevent_req_nomem(subreq, req)) {
 
3413
                return tevent_req_post(req, ev);
 
3414
        }
 
3415
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcCancel_done, req);
 
3416
        return req;
 
3417
}
 
3418
 
 
3419
static void dcerpc_eventlog6_EvtRpcCancel_done(struct tevent_req *subreq)
 
3420
{
 
3421
        struct tevent_req *req = tevent_req_callback_data(
 
3422
                subreq, struct tevent_req);
 
3423
        struct dcerpc_eventlog6_EvtRpcCancel_state *state = tevent_req_data(
 
3424
                req, struct dcerpc_eventlog6_EvtRpcCancel_state);
 
3425
        NTSTATUS status;
 
3426
        TALLOC_CTX *mem_ctx;
 
3427
 
 
3428
        if (state->out_mem_ctx) {
 
3429
                mem_ctx = state->out_mem_ctx;
 
3430
        } else {
 
3431
                mem_ctx = state;
 
3432
        }
 
3433
 
 
3434
        status = dcerpc_eventlog6_EvtRpcCancel_r_recv(subreq, mem_ctx);
 
3435
        TALLOC_FREE(subreq);
 
3436
        if (!NT_STATUS_IS_OK(status)) {
 
3437
                tevent_req_nterror(req, status);
 
3438
                return;
 
3439
        }
 
3440
 
 
3441
        /* Copy out parameters */
 
3442
 
 
3443
        /* Copy result */
 
3444
        state->orig.out.result = state->tmp.out.result;
 
3445
 
 
3446
        /* Reset temporary structure */
 
3447
        ZERO_STRUCT(state->tmp);
 
3448
 
 
3449
        tevent_req_done(req);
 
3450
}
 
3451
 
 
3452
NTSTATUS dcerpc_eventlog6_EvtRpcCancel_recv(struct tevent_req *req,
 
3453
                                            TALLOC_CTX *mem_ctx,
 
3454
                                            WERROR *result)
 
3455
{
 
3456
        struct dcerpc_eventlog6_EvtRpcCancel_state *state = tevent_req_data(
 
3457
                req, struct dcerpc_eventlog6_EvtRpcCancel_state);
 
3458
        NTSTATUS status;
 
3459
 
 
3460
        if (tevent_req_is_nterror(req, &status)) {
 
3461
                tevent_req_received(req);
 
3462
                return status;
 
3463
        }
 
3464
 
 
3465
        /* Steal possible out parameters to the callers context */
 
3466
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3467
 
 
3468
        /* Return result */
 
3469
        *result = state->orig.out.result;
 
3470
 
 
3471
        tevent_req_received(req);
 
3472
        return NT_STATUS_OK;
 
3473
}
 
3474
 
 
3475
NTSTATUS dcerpc_eventlog6_EvtRpcCancel(struct dcerpc_binding_handle *h,
 
3476
                                       TALLOC_CTX *mem_ctx,
 
3477
                                       struct policy_handle *_handle /* [in] [ref] */,
 
3478
                                       WERROR *result)
 
3479
{
 
3480
        struct eventlog6_EvtRpcCancel r;
 
3481
        NTSTATUS status;
 
3482
 
 
3483
        /* In parameters */
 
3484
        r.in.handle = _handle;
 
3485
 
 
3486
        status = dcerpc_eventlog6_EvtRpcCancel_r(h, mem_ctx, &r);
 
3487
        if (!NT_STATUS_IS_OK(status)) {
 
3488
                return status;
 
3489
        }
 
3490
 
 
3491
        /* Return variables */
 
3492
 
 
3493
        /* Return result */
 
3494
        *result = r.out.result;
 
3495
 
 
3496
        return NT_STATUS_OK;
 
3497
}
 
3498
 
 
3499
struct dcerpc_eventlog6_EvtRpcAssertConfig_r_state {
 
3500
        TALLOC_CTX *out_mem_ctx;
 
3501
};
 
3502
 
 
3503
static void dcerpc_eventlog6_EvtRpcAssertConfig_r_done(struct tevent_req *subreq);
 
3504
 
 
3505
struct tevent_req *dcerpc_eventlog6_EvtRpcAssertConfig_r_send(TALLOC_CTX *mem_ctx,
 
3506
        struct tevent_context *ev,
 
3507
        struct dcerpc_binding_handle *h,
 
3508
        struct eventlog6_EvtRpcAssertConfig *r)
 
3509
{
 
3510
        struct tevent_req *req;
 
3511
        struct dcerpc_eventlog6_EvtRpcAssertConfig_r_state *state;
 
3512
        struct tevent_req *subreq;
 
3513
 
 
3514
        req = tevent_req_create(mem_ctx, &state,
 
3515
                                struct dcerpc_eventlog6_EvtRpcAssertConfig_r_state);
 
3516
        if (req == NULL) {
 
3517
                return NULL;
 
3518
        }
 
3519
 
 
3520
        state->out_mem_ctx = NULL;
 
3521
 
 
3522
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
3523
                        NULL, &ndr_table_eventlog6,
 
3524
                        NDR_EVENTLOG6_EVTRPCASSERTCONFIG, state, r);
 
3525
        if (tevent_req_nomem(subreq, req)) {
 
3526
                return tevent_req_post(req, ev);
 
3527
        }
 
3528
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcAssertConfig_r_done, req);
 
3529
 
 
3530
        return req;
 
3531
}
 
3532
 
 
3533
static void dcerpc_eventlog6_EvtRpcAssertConfig_r_done(struct tevent_req *subreq)
 
3534
{
 
3535
        struct tevent_req *req =
 
3536
                tevent_req_callback_data(subreq,
 
3537
                struct tevent_req);
 
3538
        NTSTATUS status;
 
3539
 
 
3540
        status = dcerpc_binding_handle_call_recv(subreq);
 
3541
        if (!NT_STATUS_IS_OK(status)) {
 
3542
                tevent_req_nterror(req, status);
 
3543
                return;
 
3544
        }
 
3545
 
 
3546
        tevent_req_done(req);
 
3547
}
 
3548
 
 
3549
NTSTATUS dcerpc_eventlog6_EvtRpcAssertConfig_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
3550
{
 
3551
        struct dcerpc_eventlog6_EvtRpcAssertConfig_r_state *state =
 
3552
                tevent_req_data(req,
 
3553
                struct dcerpc_eventlog6_EvtRpcAssertConfig_r_state);
 
3554
        NTSTATUS status;
 
3555
 
 
3556
        if (tevent_req_is_nterror(req, &status)) {
 
3557
                tevent_req_received(req);
 
3558
                return status;
 
3559
        }
 
3560
 
 
3561
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3562
 
 
3563
        tevent_req_received(req);
 
3564
        return NT_STATUS_OK;
 
3565
}
 
3566
 
 
3567
NTSTATUS dcerpc_eventlog6_EvtRpcAssertConfig_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcAssertConfig *r)
 
3568
{
 
3569
        NTSTATUS status;
 
3570
 
 
3571
        status = dcerpc_binding_handle_call(h,
 
3572
                        NULL, &ndr_table_eventlog6,
 
3573
                        NDR_EVENTLOG6_EVTRPCASSERTCONFIG, mem_ctx, r);
 
3574
 
 
3575
        return status;
 
3576
}
 
3577
 
 
3578
struct dcerpc_eventlog6_EvtRpcAssertConfig_state {
 
3579
        struct eventlog6_EvtRpcAssertConfig orig;
 
3580
        struct eventlog6_EvtRpcAssertConfig tmp;
 
3581
        TALLOC_CTX *out_mem_ctx;
 
3582
};
 
3583
 
 
3584
static void dcerpc_eventlog6_EvtRpcAssertConfig_done(struct tevent_req *subreq);
 
3585
 
 
3586
struct tevent_req *dcerpc_eventlog6_EvtRpcAssertConfig_send(TALLOC_CTX *mem_ctx,
 
3587
                                                            struct tevent_context *ev,
 
3588
                                                            struct dcerpc_binding_handle *h,
 
3589
                                                            const char *_path /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
3590
                                                            uint32_t _flags /* [in]  */)
 
3591
{
 
3592
        struct tevent_req *req;
 
3593
        struct dcerpc_eventlog6_EvtRpcAssertConfig_state *state;
 
3594
        struct tevent_req *subreq;
 
3595
 
 
3596
        req = tevent_req_create(mem_ctx, &state,
 
3597
                                struct dcerpc_eventlog6_EvtRpcAssertConfig_state);
 
3598
        if (req == NULL) {
 
3599
                return NULL;
 
3600
        }
 
3601
        state->out_mem_ctx = NULL;
 
3602
 
 
3603
        /* In parameters */
 
3604
        state->orig.in.path = _path;
 
3605
        state->orig.in.flags = _flags;
 
3606
 
 
3607
        /* Out parameters */
 
3608
 
 
3609
        /* Result */
 
3610
        ZERO_STRUCT(state->orig.out.result);
 
3611
 
 
3612
        /* make a temporary copy, that we pass to the dispatch function */
 
3613
        state->tmp = state->orig;
 
3614
 
 
3615
        subreq = dcerpc_eventlog6_EvtRpcAssertConfig_r_send(state, ev, h, &state->tmp);
 
3616
        if (tevent_req_nomem(subreq, req)) {
 
3617
                return tevent_req_post(req, ev);
 
3618
        }
 
3619
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcAssertConfig_done, req);
 
3620
        return req;
 
3621
}
 
3622
 
 
3623
static void dcerpc_eventlog6_EvtRpcAssertConfig_done(struct tevent_req *subreq)
 
3624
{
 
3625
        struct tevent_req *req = tevent_req_callback_data(
 
3626
                subreq, struct tevent_req);
 
3627
        struct dcerpc_eventlog6_EvtRpcAssertConfig_state *state = tevent_req_data(
 
3628
                req, struct dcerpc_eventlog6_EvtRpcAssertConfig_state);
 
3629
        NTSTATUS status;
 
3630
        TALLOC_CTX *mem_ctx;
 
3631
 
 
3632
        if (state->out_mem_ctx) {
 
3633
                mem_ctx = state->out_mem_ctx;
 
3634
        } else {
 
3635
                mem_ctx = state;
 
3636
        }
 
3637
 
 
3638
        status = dcerpc_eventlog6_EvtRpcAssertConfig_r_recv(subreq, mem_ctx);
 
3639
        TALLOC_FREE(subreq);
 
3640
        if (!NT_STATUS_IS_OK(status)) {
 
3641
                tevent_req_nterror(req, status);
 
3642
                return;
 
3643
        }
 
3644
 
 
3645
        /* Copy out parameters */
 
3646
 
 
3647
        /* Copy result */
 
3648
        state->orig.out.result = state->tmp.out.result;
 
3649
 
 
3650
        /* Reset temporary structure */
 
3651
        ZERO_STRUCT(state->tmp);
 
3652
 
 
3653
        tevent_req_done(req);
 
3654
}
 
3655
 
 
3656
NTSTATUS dcerpc_eventlog6_EvtRpcAssertConfig_recv(struct tevent_req *req,
 
3657
                                                  TALLOC_CTX *mem_ctx,
 
3658
                                                  WERROR *result)
 
3659
{
 
3660
        struct dcerpc_eventlog6_EvtRpcAssertConfig_state *state = tevent_req_data(
 
3661
                req, struct dcerpc_eventlog6_EvtRpcAssertConfig_state);
 
3662
        NTSTATUS status;
 
3663
 
 
3664
        if (tevent_req_is_nterror(req, &status)) {
 
3665
                tevent_req_received(req);
 
3666
                return status;
 
3667
        }
 
3668
 
 
3669
        /* Steal possible out parameters to the callers context */
 
3670
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3671
 
 
3672
        /* Return result */
 
3673
        *result = state->orig.out.result;
 
3674
 
 
3675
        tevent_req_received(req);
 
3676
        return NT_STATUS_OK;
 
3677
}
 
3678
 
 
3679
NTSTATUS dcerpc_eventlog6_EvtRpcAssertConfig(struct dcerpc_binding_handle *h,
 
3680
                                             TALLOC_CTX *mem_ctx,
 
3681
                                             const char *_path /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
3682
                                             uint32_t _flags /* [in]  */,
 
3683
                                             WERROR *result)
 
3684
{
 
3685
        struct eventlog6_EvtRpcAssertConfig r;
 
3686
        NTSTATUS status;
 
3687
 
 
3688
        /* In parameters */
 
3689
        r.in.path = _path;
 
3690
        r.in.flags = _flags;
 
3691
 
 
3692
        status = dcerpc_eventlog6_EvtRpcAssertConfig_r(h, mem_ctx, &r);
 
3693
        if (!NT_STATUS_IS_OK(status)) {
 
3694
                return status;
 
3695
        }
 
3696
 
 
3697
        /* Return variables */
 
3698
 
 
3699
        /* Return result */
 
3700
        *result = r.out.result;
 
3701
 
 
3702
        return NT_STATUS_OK;
 
3703
}
 
3704
 
 
3705
struct dcerpc_eventlog6_EvtRpcRetractConfig_r_state {
 
3706
        TALLOC_CTX *out_mem_ctx;
 
3707
};
 
3708
 
 
3709
static void dcerpc_eventlog6_EvtRpcRetractConfig_r_done(struct tevent_req *subreq);
 
3710
 
 
3711
struct tevent_req *dcerpc_eventlog6_EvtRpcRetractConfig_r_send(TALLOC_CTX *mem_ctx,
 
3712
        struct tevent_context *ev,
 
3713
        struct dcerpc_binding_handle *h,
 
3714
        struct eventlog6_EvtRpcRetractConfig *r)
 
3715
{
 
3716
        struct tevent_req *req;
 
3717
        struct dcerpc_eventlog6_EvtRpcRetractConfig_r_state *state;
 
3718
        struct tevent_req *subreq;
 
3719
 
 
3720
        req = tevent_req_create(mem_ctx, &state,
 
3721
                                struct dcerpc_eventlog6_EvtRpcRetractConfig_r_state);
 
3722
        if (req == NULL) {
 
3723
                return NULL;
 
3724
        }
 
3725
 
 
3726
        state->out_mem_ctx = NULL;
 
3727
 
 
3728
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
3729
                        NULL, &ndr_table_eventlog6,
 
3730
                        NDR_EVENTLOG6_EVTRPCRETRACTCONFIG, state, r);
 
3731
        if (tevent_req_nomem(subreq, req)) {
 
3732
                return tevent_req_post(req, ev);
 
3733
        }
 
3734
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRetractConfig_r_done, req);
 
3735
 
 
3736
        return req;
 
3737
}
 
3738
 
 
3739
static void dcerpc_eventlog6_EvtRpcRetractConfig_r_done(struct tevent_req *subreq)
 
3740
{
 
3741
        struct tevent_req *req =
 
3742
                tevent_req_callback_data(subreq,
 
3743
                struct tevent_req);
 
3744
        NTSTATUS status;
 
3745
 
 
3746
        status = dcerpc_binding_handle_call_recv(subreq);
 
3747
        if (!NT_STATUS_IS_OK(status)) {
 
3748
                tevent_req_nterror(req, status);
 
3749
                return;
 
3750
        }
 
3751
 
 
3752
        tevent_req_done(req);
 
3753
}
 
3754
 
 
3755
NTSTATUS dcerpc_eventlog6_EvtRpcRetractConfig_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
3756
{
 
3757
        struct dcerpc_eventlog6_EvtRpcRetractConfig_r_state *state =
 
3758
                tevent_req_data(req,
 
3759
                struct dcerpc_eventlog6_EvtRpcRetractConfig_r_state);
 
3760
        NTSTATUS status;
 
3761
 
 
3762
        if (tevent_req_is_nterror(req, &status)) {
 
3763
                tevent_req_received(req);
 
3764
                return status;
 
3765
        }
 
3766
 
 
3767
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3768
 
 
3769
        tevent_req_received(req);
 
3770
        return NT_STATUS_OK;
 
3771
}
 
3772
 
 
3773
NTSTATUS dcerpc_eventlog6_EvtRpcRetractConfig_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcRetractConfig *r)
 
3774
{
 
3775
        NTSTATUS status;
 
3776
 
 
3777
        status = dcerpc_binding_handle_call(h,
 
3778
                        NULL, &ndr_table_eventlog6,
 
3779
                        NDR_EVENTLOG6_EVTRPCRETRACTCONFIG, mem_ctx, r);
 
3780
 
 
3781
        return status;
 
3782
}
 
3783
 
 
3784
struct dcerpc_eventlog6_EvtRpcRetractConfig_state {
 
3785
        struct eventlog6_EvtRpcRetractConfig orig;
 
3786
        struct eventlog6_EvtRpcRetractConfig tmp;
 
3787
        TALLOC_CTX *out_mem_ctx;
 
3788
};
 
3789
 
 
3790
static void dcerpc_eventlog6_EvtRpcRetractConfig_done(struct tevent_req *subreq);
 
3791
 
 
3792
struct tevent_req *dcerpc_eventlog6_EvtRpcRetractConfig_send(TALLOC_CTX *mem_ctx,
 
3793
                                                             struct tevent_context *ev,
 
3794
                                                             struct dcerpc_binding_handle *h,
 
3795
                                                             const char *_path /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
3796
                                                             uint32_t _flags /* [in]  */)
 
3797
{
 
3798
        struct tevent_req *req;
 
3799
        struct dcerpc_eventlog6_EvtRpcRetractConfig_state *state;
 
3800
        struct tevent_req *subreq;
 
3801
 
 
3802
        req = tevent_req_create(mem_ctx, &state,
 
3803
                                struct dcerpc_eventlog6_EvtRpcRetractConfig_state);
 
3804
        if (req == NULL) {
 
3805
                return NULL;
 
3806
        }
 
3807
        state->out_mem_ctx = NULL;
 
3808
 
 
3809
        /* In parameters */
 
3810
        state->orig.in.path = _path;
 
3811
        state->orig.in.flags = _flags;
 
3812
 
 
3813
        /* Out parameters */
 
3814
 
 
3815
        /* Result */
 
3816
        ZERO_STRUCT(state->orig.out.result);
 
3817
 
 
3818
        /* make a temporary copy, that we pass to the dispatch function */
 
3819
        state->tmp = state->orig;
 
3820
 
 
3821
        subreq = dcerpc_eventlog6_EvtRpcRetractConfig_r_send(state, ev, h, &state->tmp);
 
3822
        if (tevent_req_nomem(subreq, req)) {
 
3823
                return tevent_req_post(req, ev);
 
3824
        }
 
3825
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcRetractConfig_done, req);
 
3826
        return req;
 
3827
}
 
3828
 
 
3829
static void dcerpc_eventlog6_EvtRpcRetractConfig_done(struct tevent_req *subreq)
 
3830
{
 
3831
        struct tevent_req *req = tevent_req_callback_data(
 
3832
                subreq, struct tevent_req);
 
3833
        struct dcerpc_eventlog6_EvtRpcRetractConfig_state *state = tevent_req_data(
 
3834
                req, struct dcerpc_eventlog6_EvtRpcRetractConfig_state);
 
3835
        NTSTATUS status;
 
3836
        TALLOC_CTX *mem_ctx;
 
3837
 
 
3838
        if (state->out_mem_ctx) {
 
3839
                mem_ctx = state->out_mem_ctx;
 
3840
        } else {
 
3841
                mem_ctx = state;
 
3842
        }
 
3843
 
 
3844
        status = dcerpc_eventlog6_EvtRpcRetractConfig_r_recv(subreq, mem_ctx);
 
3845
        TALLOC_FREE(subreq);
 
3846
        if (!NT_STATUS_IS_OK(status)) {
 
3847
                tevent_req_nterror(req, status);
 
3848
                return;
 
3849
        }
 
3850
 
 
3851
        /* Copy out parameters */
 
3852
 
 
3853
        /* Copy result */
 
3854
        state->orig.out.result = state->tmp.out.result;
 
3855
 
 
3856
        /* Reset temporary structure */
 
3857
        ZERO_STRUCT(state->tmp);
 
3858
 
 
3859
        tevent_req_done(req);
 
3860
}
 
3861
 
 
3862
NTSTATUS dcerpc_eventlog6_EvtRpcRetractConfig_recv(struct tevent_req *req,
 
3863
                                                   TALLOC_CTX *mem_ctx,
 
3864
                                                   WERROR *result)
 
3865
{
 
3866
        struct dcerpc_eventlog6_EvtRpcRetractConfig_state *state = tevent_req_data(
 
3867
                req, struct dcerpc_eventlog6_EvtRpcRetractConfig_state);
 
3868
        NTSTATUS status;
 
3869
 
 
3870
        if (tevent_req_is_nterror(req, &status)) {
 
3871
                tevent_req_received(req);
 
3872
                return status;
 
3873
        }
 
3874
 
 
3875
        /* Steal possible out parameters to the callers context */
 
3876
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3877
 
 
3878
        /* Return result */
 
3879
        *result = state->orig.out.result;
 
3880
 
 
3881
        tevent_req_received(req);
 
3882
        return NT_STATUS_OK;
 
3883
}
 
3884
 
 
3885
NTSTATUS dcerpc_eventlog6_EvtRpcRetractConfig(struct dcerpc_binding_handle *h,
 
3886
                                              TALLOC_CTX *mem_ctx,
 
3887
                                              const char *_path /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
3888
                                              uint32_t _flags /* [in]  */,
 
3889
                                              WERROR *result)
 
3890
{
 
3891
        struct eventlog6_EvtRpcRetractConfig r;
 
3892
        NTSTATUS status;
 
3893
 
 
3894
        /* In parameters */
 
3895
        r.in.path = _path;
 
3896
        r.in.flags = _flags;
 
3897
 
 
3898
        status = dcerpc_eventlog6_EvtRpcRetractConfig_r(h, mem_ctx, &r);
 
3899
        if (!NT_STATUS_IS_OK(status)) {
 
3900
                return status;
 
3901
        }
 
3902
 
 
3903
        /* Return variables */
 
3904
 
 
3905
        /* Return result */
 
3906
        *result = r.out.result;
 
3907
 
 
3908
        return NT_STATUS_OK;
 
3909
}
 
3910
 
 
3911
struct dcerpc_eventlog6_EvtRpcOpenLogHandle_r_state {
 
3912
        TALLOC_CTX *out_mem_ctx;
 
3913
};
 
3914
 
 
3915
static void dcerpc_eventlog6_EvtRpcOpenLogHandle_r_done(struct tevent_req *subreq);
 
3916
 
 
3917
struct tevent_req *dcerpc_eventlog6_EvtRpcOpenLogHandle_r_send(TALLOC_CTX *mem_ctx,
 
3918
        struct tevent_context *ev,
 
3919
        struct dcerpc_binding_handle *h,
 
3920
        struct eventlog6_EvtRpcOpenLogHandle *r)
 
3921
{
 
3922
        struct tevent_req *req;
 
3923
        struct dcerpc_eventlog6_EvtRpcOpenLogHandle_r_state *state;
 
3924
        struct tevent_req *subreq;
 
3925
 
 
3926
        req = tevent_req_create(mem_ctx, &state,
 
3927
                                struct dcerpc_eventlog6_EvtRpcOpenLogHandle_r_state);
 
3928
        if (req == NULL) {
 
3929
                return NULL;
 
3930
        }
 
3931
 
 
3932
        state->out_mem_ctx = talloc_new(state);
 
3933
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
3934
                return tevent_req_post(req, ev);
 
3935
        }
 
3936
 
 
3937
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
3938
                        NULL, &ndr_table_eventlog6,
 
3939
                        NDR_EVENTLOG6_EVTRPCOPENLOGHANDLE, state->out_mem_ctx, r);
 
3940
        if (tevent_req_nomem(subreq, req)) {
 
3941
                return tevent_req_post(req, ev);
 
3942
        }
 
3943
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcOpenLogHandle_r_done, req);
 
3944
 
 
3945
        return req;
 
3946
}
 
3947
 
 
3948
static void dcerpc_eventlog6_EvtRpcOpenLogHandle_r_done(struct tevent_req *subreq)
 
3949
{
 
3950
        struct tevent_req *req =
 
3951
                tevent_req_callback_data(subreq,
 
3952
                struct tevent_req);
 
3953
        NTSTATUS status;
 
3954
 
 
3955
        status = dcerpc_binding_handle_call_recv(subreq);
 
3956
        if (!NT_STATUS_IS_OK(status)) {
 
3957
                tevent_req_nterror(req, status);
 
3958
                return;
 
3959
        }
 
3960
 
 
3961
        tevent_req_done(req);
 
3962
}
 
3963
 
 
3964
NTSTATUS dcerpc_eventlog6_EvtRpcOpenLogHandle_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
3965
{
 
3966
        struct dcerpc_eventlog6_EvtRpcOpenLogHandle_r_state *state =
 
3967
                tevent_req_data(req,
 
3968
                struct dcerpc_eventlog6_EvtRpcOpenLogHandle_r_state);
 
3969
        NTSTATUS status;
 
3970
 
 
3971
        if (tevent_req_is_nterror(req, &status)) {
 
3972
                tevent_req_received(req);
 
3973
                return status;
 
3974
        }
 
3975
 
 
3976
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
3977
 
 
3978
        tevent_req_received(req);
 
3979
        return NT_STATUS_OK;
 
3980
}
 
3981
 
 
3982
NTSTATUS dcerpc_eventlog6_EvtRpcOpenLogHandle_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcOpenLogHandle *r)
 
3983
{
 
3984
        NTSTATUS status;
 
3985
 
 
3986
        status = dcerpc_binding_handle_call(h,
 
3987
                        NULL, &ndr_table_eventlog6,
 
3988
                        NDR_EVENTLOG6_EVTRPCOPENLOGHANDLE, mem_ctx, r);
 
3989
 
 
3990
        return status;
 
3991
}
 
3992
 
 
3993
struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state {
 
3994
        struct eventlog6_EvtRpcOpenLogHandle orig;
 
3995
        struct eventlog6_EvtRpcOpenLogHandle tmp;
 
3996
        TALLOC_CTX *out_mem_ctx;
 
3997
};
 
3998
 
 
3999
static void dcerpc_eventlog6_EvtRpcOpenLogHandle_done(struct tevent_req *subreq);
 
4000
 
 
4001
struct tevent_req *dcerpc_eventlog6_EvtRpcOpenLogHandle_send(TALLOC_CTX *mem_ctx,
 
4002
                                                             struct tevent_context *ev,
 
4003
                                                             struct dcerpc_binding_handle *h,
 
4004
                                                             const char *_channel /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
4005
                                                             uint32_t _flags /* [in]  */,
 
4006
                                                             struct policy_handle *_handle /* [out] [ref] */,
 
4007
                                                             struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
4008
{
 
4009
        struct tevent_req *req;
 
4010
        struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state *state;
 
4011
        struct tevent_req *subreq;
 
4012
 
 
4013
        req = tevent_req_create(mem_ctx, &state,
 
4014
                                struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state);
 
4015
        if (req == NULL) {
 
4016
                return NULL;
 
4017
        }
 
4018
        state->out_mem_ctx = NULL;
 
4019
 
 
4020
        /* In parameters */
 
4021
        state->orig.in.channel = _channel;
 
4022
        state->orig.in.flags = _flags;
 
4023
 
 
4024
        /* Out parameters */
 
4025
        state->orig.out.handle = _handle;
 
4026
        state->orig.out.error = _error;
 
4027
 
 
4028
        /* Result */
 
4029
        ZERO_STRUCT(state->orig.out.result);
 
4030
 
 
4031
        state->out_mem_ctx = talloc_named_const(state, 0,
 
4032
                             "dcerpc_eventlog6_EvtRpcOpenLogHandle_out_memory");
 
4033
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4034
                return tevent_req_post(req, ev);
 
4035
        }
 
4036
 
 
4037
        /* make a temporary copy, that we pass to the dispatch function */
 
4038
        state->tmp = state->orig;
 
4039
 
 
4040
        subreq = dcerpc_eventlog6_EvtRpcOpenLogHandle_r_send(state, ev, h, &state->tmp);
 
4041
        if (tevent_req_nomem(subreq, req)) {
 
4042
                return tevent_req_post(req, ev);
 
4043
        }
 
4044
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcOpenLogHandle_done, req);
 
4045
        return req;
 
4046
}
 
4047
 
 
4048
static void dcerpc_eventlog6_EvtRpcOpenLogHandle_done(struct tevent_req *subreq)
 
4049
{
 
4050
        struct tevent_req *req = tevent_req_callback_data(
 
4051
                subreq, struct tevent_req);
 
4052
        struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state *state = tevent_req_data(
 
4053
                req, struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state);
 
4054
        NTSTATUS status;
 
4055
        TALLOC_CTX *mem_ctx;
 
4056
 
 
4057
        if (state->out_mem_ctx) {
 
4058
                mem_ctx = state->out_mem_ctx;
 
4059
        } else {
 
4060
                mem_ctx = state;
 
4061
        }
 
4062
 
 
4063
        status = dcerpc_eventlog6_EvtRpcOpenLogHandle_r_recv(subreq, mem_ctx);
 
4064
        TALLOC_FREE(subreq);
 
4065
        if (!NT_STATUS_IS_OK(status)) {
 
4066
                tevent_req_nterror(req, status);
 
4067
                return;
 
4068
        }
 
4069
 
 
4070
        /* Copy out parameters */
 
4071
        *state->orig.out.handle = *state->tmp.out.handle;
 
4072
        *state->orig.out.error = *state->tmp.out.error;
 
4073
 
 
4074
        /* Copy result */
 
4075
        state->orig.out.result = state->tmp.out.result;
 
4076
 
 
4077
        /* Reset temporary structure */
 
4078
        ZERO_STRUCT(state->tmp);
 
4079
 
 
4080
        tevent_req_done(req);
 
4081
}
 
4082
 
 
4083
NTSTATUS dcerpc_eventlog6_EvtRpcOpenLogHandle_recv(struct tevent_req *req,
 
4084
                                                   TALLOC_CTX *mem_ctx,
 
4085
                                                   WERROR *result)
 
4086
{
 
4087
        struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state *state = tevent_req_data(
 
4088
                req, struct dcerpc_eventlog6_EvtRpcOpenLogHandle_state);
 
4089
        NTSTATUS status;
 
4090
 
 
4091
        if (tevent_req_is_nterror(req, &status)) {
 
4092
                tevent_req_received(req);
 
4093
                return status;
 
4094
        }
 
4095
 
 
4096
        /* Steal possible out parameters to the callers context */
 
4097
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4098
 
 
4099
        /* Return result */
 
4100
        *result = state->orig.out.result;
 
4101
 
 
4102
        tevent_req_received(req);
 
4103
        return NT_STATUS_OK;
 
4104
}
 
4105
 
 
4106
NTSTATUS dcerpc_eventlog6_EvtRpcOpenLogHandle(struct dcerpc_binding_handle *h,
 
4107
                                              TALLOC_CTX *mem_ctx,
 
4108
                                              const char *_channel /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
4109
                                              uint32_t _flags /* [in]  */,
 
4110
                                              struct policy_handle *_handle /* [out] [ref] */,
 
4111
                                              struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
4112
                                              WERROR *result)
 
4113
{
 
4114
        struct eventlog6_EvtRpcOpenLogHandle r;
 
4115
        NTSTATUS status;
 
4116
 
 
4117
        /* In parameters */
 
4118
        r.in.channel = _channel;
 
4119
        r.in.flags = _flags;
 
4120
 
 
4121
        status = dcerpc_eventlog6_EvtRpcOpenLogHandle_r(h, mem_ctx, &r);
 
4122
        if (!NT_STATUS_IS_OK(status)) {
 
4123
                return status;
 
4124
        }
 
4125
 
 
4126
        /* Return variables */
 
4127
        *_handle = *r.out.handle;
 
4128
        *_error = *r.out.error;
 
4129
 
 
4130
        /* Return result */
 
4131
        *result = r.out.result;
 
4132
 
 
4133
        return NT_STATUS_OK;
 
4134
}
 
4135
 
 
4136
struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_state {
 
4137
        TALLOC_CTX *out_mem_ctx;
 
4138
};
 
4139
 
 
4140
static void dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_done(struct tevent_req *subreq);
 
4141
 
 
4142
struct tevent_req *dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_send(TALLOC_CTX *mem_ctx,
 
4143
        struct tevent_context *ev,
 
4144
        struct dcerpc_binding_handle *h,
 
4145
        struct eventlog6_EvtRpcGetLogFileInfo *r)
 
4146
{
 
4147
        struct tevent_req *req;
 
4148
        struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_state *state;
 
4149
        struct tevent_req *subreq;
 
4150
 
 
4151
        req = tevent_req_create(mem_ctx, &state,
 
4152
                                struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_state);
 
4153
        if (req == NULL) {
 
4154
                return NULL;
 
4155
        }
 
4156
 
 
4157
        state->out_mem_ctx = talloc_new(state);
 
4158
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4159
                return tevent_req_post(req, ev);
 
4160
        }
 
4161
 
 
4162
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
4163
                        NULL, &ndr_table_eventlog6,
 
4164
                        NDR_EVENTLOG6_EVTRPCGETLOGFILEINFO, state->out_mem_ctx, r);
 
4165
        if (tevent_req_nomem(subreq, req)) {
 
4166
                return tevent_req_post(req, ev);
 
4167
        }
 
4168
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_done, req);
 
4169
 
 
4170
        return req;
 
4171
}
 
4172
 
 
4173
static void dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_done(struct tevent_req *subreq)
 
4174
{
 
4175
        struct tevent_req *req =
 
4176
                tevent_req_callback_data(subreq,
 
4177
                struct tevent_req);
 
4178
        NTSTATUS status;
 
4179
 
 
4180
        status = dcerpc_binding_handle_call_recv(subreq);
 
4181
        if (!NT_STATUS_IS_OK(status)) {
 
4182
                tevent_req_nterror(req, status);
 
4183
                return;
 
4184
        }
 
4185
 
 
4186
        tevent_req_done(req);
 
4187
}
 
4188
 
 
4189
NTSTATUS dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
4190
{
 
4191
        struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_state *state =
 
4192
                tevent_req_data(req,
 
4193
                struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_state);
 
4194
        NTSTATUS status;
 
4195
 
 
4196
        if (tevent_req_is_nterror(req, &status)) {
 
4197
                tevent_req_received(req);
 
4198
                return status;
 
4199
        }
 
4200
 
 
4201
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4202
 
 
4203
        tevent_req_received(req);
 
4204
        return NT_STATUS_OK;
 
4205
}
 
4206
 
 
4207
NTSTATUS dcerpc_eventlog6_EvtRpcGetLogFileInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetLogFileInfo *r)
 
4208
{
 
4209
        NTSTATUS status;
 
4210
 
 
4211
        status = dcerpc_binding_handle_call(h,
 
4212
                        NULL, &ndr_table_eventlog6,
 
4213
                        NDR_EVENTLOG6_EVTRPCGETLOGFILEINFO, mem_ctx, r);
 
4214
 
 
4215
        return status;
 
4216
}
 
4217
 
 
4218
struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state {
 
4219
        struct eventlog6_EvtRpcGetLogFileInfo orig;
 
4220
        struct eventlog6_EvtRpcGetLogFileInfo tmp;
 
4221
        TALLOC_CTX *out_mem_ctx;
 
4222
};
 
4223
 
 
4224
static void dcerpc_eventlog6_EvtRpcGetLogFileInfo_done(struct tevent_req *subreq);
 
4225
 
 
4226
struct tevent_req *dcerpc_eventlog6_EvtRpcGetLogFileInfo_send(TALLOC_CTX *mem_ctx,
 
4227
                                                              struct tevent_context *ev,
 
4228
                                                              struct dcerpc_binding_handle *h,
 
4229
                                                              struct policy_handle *_logHandle /* [in] [ref] */,
 
4230
                                                              uint32_t _propertyId /* [in]  */,
 
4231
                                                              uint32_t _propertyValueBufferSize /* [in] [range(0,MAX_RPC_PROPERTY_BUFFER_SIZE)] */,
 
4232
                                                              uint8_t *_propertyValueBuffer /* [out] [ref,size_is(propertyValueBufferSize)] */,
 
4233
                                                              uint32_t *_propertyValueBufferLength /* [out] [ref] */)
 
4234
{
 
4235
        struct tevent_req *req;
 
4236
        struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state *state;
 
4237
        struct tevent_req *subreq;
 
4238
 
 
4239
        req = tevent_req_create(mem_ctx, &state,
 
4240
                                struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state);
 
4241
        if (req == NULL) {
 
4242
                return NULL;
 
4243
        }
 
4244
        state->out_mem_ctx = NULL;
 
4245
 
 
4246
        /* In parameters */
 
4247
        state->orig.in.logHandle = _logHandle;
 
4248
        state->orig.in.propertyId = _propertyId;
 
4249
        state->orig.in.propertyValueBufferSize = _propertyValueBufferSize;
 
4250
 
 
4251
        /* Out parameters */
 
4252
        state->orig.out.propertyValueBuffer = _propertyValueBuffer;
 
4253
        state->orig.out.propertyValueBufferLength = _propertyValueBufferLength;
 
4254
 
 
4255
        /* Result */
 
4256
        ZERO_STRUCT(state->orig.out.result);
 
4257
 
 
4258
        state->out_mem_ctx = talloc_named_const(state, 0,
 
4259
                             "dcerpc_eventlog6_EvtRpcGetLogFileInfo_out_memory");
 
4260
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4261
                return tevent_req_post(req, ev);
 
4262
        }
 
4263
 
 
4264
        /* make a temporary copy, that we pass to the dispatch function */
 
4265
        state->tmp = state->orig;
 
4266
 
 
4267
        subreq = dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_send(state, ev, h, &state->tmp);
 
4268
        if (tevent_req_nomem(subreq, req)) {
 
4269
                return tevent_req_post(req, ev);
 
4270
        }
 
4271
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetLogFileInfo_done, req);
 
4272
        return req;
 
4273
}
 
4274
 
 
4275
static void dcerpc_eventlog6_EvtRpcGetLogFileInfo_done(struct tevent_req *subreq)
 
4276
{
 
4277
        struct tevent_req *req = tevent_req_callback_data(
 
4278
                subreq, struct tevent_req);
 
4279
        struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state *state = tevent_req_data(
 
4280
                req, struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state);
 
4281
        NTSTATUS status;
 
4282
        TALLOC_CTX *mem_ctx;
 
4283
 
 
4284
        if (state->out_mem_ctx) {
 
4285
                mem_ctx = state->out_mem_ctx;
 
4286
        } else {
 
4287
                mem_ctx = state;
 
4288
        }
 
4289
 
 
4290
        status = dcerpc_eventlog6_EvtRpcGetLogFileInfo_r_recv(subreq, mem_ctx);
 
4291
        TALLOC_FREE(subreq);
 
4292
        if (!NT_STATUS_IS_OK(status)) {
 
4293
                tevent_req_nterror(req, status);
 
4294
                return;
 
4295
        }
 
4296
 
 
4297
        /* Copy out parameters */
 
4298
        {
 
4299
                size_t _copy_len_propertyValueBuffer;
 
4300
                _copy_len_propertyValueBuffer = state->tmp.in.propertyValueBufferSize;
 
4301
                memcpy(state->orig.out.propertyValueBuffer, state->tmp.out.propertyValueBuffer, _copy_len_propertyValueBuffer * sizeof(*state->orig.out.propertyValueBuffer));
 
4302
        }
 
4303
        *state->orig.out.propertyValueBufferLength = *state->tmp.out.propertyValueBufferLength;
 
4304
 
 
4305
        /* Copy result */
 
4306
        state->orig.out.result = state->tmp.out.result;
 
4307
 
 
4308
        /* Reset temporary structure */
 
4309
        ZERO_STRUCT(state->tmp);
 
4310
 
 
4311
        tevent_req_done(req);
 
4312
}
 
4313
 
 
4314
NTSTATUS dcerpc_eventlog6_EvtRpcGetLogFileInfo_recv(struct tevent_req *req,
 
4315
                                                    TALLOC_CTX *mem_ctx,
 
4316
                                                    WERROR *result)
 
4317
{
 
4318
        struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state *state = tevent_req_data(
 
4319
                req, struct dcerpc_eventlog6_EvtRpcGetLogFileInfo_state);
 
4320
        NTSTATUS status;
 
4321
 
 
4322
        if (tevent_req_is_nterror(req, &status)) {
 
4323
                tevent_req_received(req);
 
4324
                return status;
 
4325
        }
 
4326
 
 
4327
        /* Steal possible out parameters to the callers context */
 
4328
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4329
 
 
4330
        /* Return result */
 
4331
        *result = state->orig.out.result;
 
4332
 
 
4333
        tevent_req_received(req);
 
4334
        return NT_STATUS_OK;
 
4335
}
 
4336
 
 
4337
NTSTATUS dcerpc_eventlog6_EvtRpcGetLogFileInfo(struct dcerpc_binding_handle *h,
 
4338
                                               TALLOC_CTX *mem_ctx,
 
4339
                                               struct policy_handle *_logHandle /* [in] [ref] */,
 
4340
                                               uint32_t _propertyId /* [in]  */,
 
4341
                                               uint32_t _propertyValueBufferSize /* [in] [range(0,MAX_RPC_PROPERTY_BUFFER_SIZE)] */,
 
4342
                                               uint8_t *_propertyValueBuffer /* [out] [ref,size_is(propertyValueBufferSize)] */,
 
4343
                                               uint32_t *_propertyValueBufferLength /* [out] [ref] */,
 
4344
                                               WERROR *result)
 
4345
{
 
4346
        struct eventlog6_EvtRpcGetLogFileInfo r;
 
4347
        NTSTATUS status;
 
4348
 
 
4349
        /* In parameters */
 
4350
        r.in.logHandle = _logHandle;
 
4351
        r.in.propertyId = _propertyId;
 
4352
        r.in.propertyValueBufferSize = _propertyValueBufferSize;
 
4353
 
 
4354
        status = dcerpc_eventlog6_EvtRpcGetLogFileInfo_r(h, mem_ctx, &r);
 
4355
        if (!NT_STATUS_IS_OK(status)) {
 
4356
                return status;
 
4357
        }
 
4358
 
 
4359
        /* Return variables */
 
4360
        {
 
4361
                size_t _copy_len_propertyValueBuffer;
 
4362
                _copy_len_propertyValueBuffer = r.in.propertyValueBufferSize;
 
4363
                memcpy(_propertyValueBuffer, r.out.propertyValueBuffer, _copy_len_propertyValueBuffer * sizeof(*_propertyValueBuffer));
 
4364
        }
 
4365
        *_propertyValueBufferLength = *r.out.propertyValueBufferLength;
 
4366
 
 
4367
        /* Return result */
 
4368
        *result = r.out.result;
 
4369
 
 
4370
        return NT_STATUS_OK;
 
4371
}
 
4372
 
 
4373
struct dcerpc_eventlog6_EvtRpcGetChannelList_r_state {
 
4374
        TALLOC_CTX *out_mem_ctx;
 
4375
};
 
4376
 
 
4377
static void dcerpc_eventlog6_EvtRpcGetChannelList_r_done(struct tevent_req *subreq);
 
4378
 
 
4379
struct tevent_req *dcerpc_eventlog6_EvtRpcGetChannelList_r_send(TALLOC_CTX *mem_ctx,
 
4380
        struct tevent_context *ev,
 
4381
        struct dcerpc_binding_handle *h,
 
4382
        struct eventlog6_EvtRpcGetChannelList *r)
 
4383
{
 
4384
        struct tevent_req *req;
 
4385
        struct dcerpc_eventlog6_EvtRpcGetChannelList_r_state *state;
 
4386
        struct tevent_req *subreq;
 
4387
 
 
4388
        req = tevent_req_create(mem_ctx, &state,
 
4389
                                struct dcerpc_eventlog6_EvtRpcGetChannelList_r_state);
 
4390
        if (req == NULL) {
 
4391
                return NULL;
 
4392
        }
 
4393
 
 
4394
        state->out_mem_ctx = talloc_new(state);
 
4395
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4396
                return tevent_req_post(req, ev);
 
4397
        }
 
4398
 
 
4399
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
4400
                        NULL, &ndr_table_eventlog6,
 
4401
                        NDR_EVENTLOG6_EVTRPCGETCHANNELLIST, state->out_mem_ctx, r);
 
4402
        if (tevent_req_nomem(subreq, req)) {
 
4403
                return tevent_req_post(req, ev);
 
4404
        }
 
4405
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetChannelList_r_done, req);
 
4406
 
 
4407
        return req;
 
4408
}
 
4409
 
 
4410
static void dcerpc_eventlog6_EvtRpcGetChannelList_r_done(struct tevent_req *subreq)
 
4411
{
 
4412
        struct tevent_req *req =
 
4413
                tevent_req_callback_data(subreq,
 
4414
                struct tevent_req);
 
4415
        NTSTATUS status;
 
4416
 
 
4417
        status = dcerpc_binding_handle_call_recv(subreq);
 
4418
        if (!NT_STATUS_IS_OK(status)) {
 
4419
                tevent_req_nterror(req, status);
 
4420
                return;
 
4421
        }
 
4422
 
 
4423
        tevent_req_done(req);
 
4424
}
 
4425
 
 
4426
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelList_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
4427
{
 
4428
        struct dcerpc_eventlog6_EvtRpcGetChannelList_r_state *state =
 
4429
                tevent_req_data(req,
 
4430
                struct dcerpc_eventlog6_EvtRpcGetChannelList_r_state);
 
4431
        NTSTATUS status;
 
4432
 
 
4433
        if (tevent_req_is_nterror(req, &status)) {
 
4434
                tevent_req_received(req);
 
4435
                return status;
 
4436
        }
 
4437
 
 
4438
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4439
 
 
4440
        tevent_req_received(req);
 
4441
        return NT_STATUS_OK;
 
4442
}
 
4443
 
 
4444
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelList_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetChannelList *r)
 
4445
{
 
4446
        NTSTATUS status;
 
4447
 
 
4448
        status = dcerpc_binding_handle_call(h,
 
4449
                        NULL, &ndr_table_eventlog6,
 
4450
                        NDR_EVENTLOG6_EVTRPCGETCHANNELLIST, mem_ctx, r);
 
4451
 
 
4452
        return status;
 
4453
}
 
4454
 
 
4455
struct dcerpc_eventlog6_EvtRpcGetChannelList_state {
 
4456
        struct eventlog6_EvtRpcGetChannelList orig;
 
4457
        struct eventlog6_EvtRpcGetChannelList tmp;
 
4458
        TALLOC_CTX *out_mem_ctx;
 
4459
};
 
4460
 
 
4461
static void dcerpc_eventlog6_EvtRpcGetChannelList_done(struct tevent_req *subreq);
 
4462
 
 
4463
struct tevent_req *dcerpc_eventlog6_EvtRpcGetChannelList_send(TALLOC_CTX *mem_ctx,
 
4464
                                                              struct tevent_context *ev,
 
4465
                                                              struct dcerpc_binding_handle *h,
 
4466
                                                              uint32_t _flags /* [in]  */,
 
4467
                                                              uint32_t *_numChannelPaths /* [out] [ref] */,
 
4468
                                                              const char ***_channelPaths /* [out] [ref,range(0,MAX_RPC_CHANNEL_COUNT),charset(UTF16),size_is(,*numChannelPaths)] */)
 
4469
{
 
4470
        struct tevent_req *req;
 
4471
        struct dcerpc_eventlog6_EvtRpcGetChannelList_state *state;
 
4472
        struct tevent_req *subreq;
 
4473
 
 
4474
        req = tevent_req_create(mem_ctx, &state,
 
4475
                                struct dcerpc_eventlog6_EvtRpcGetChannelList_state);
 
4476
        if (req == NULL) {
 
4477
                return NULL;
 
4478
        }
 
4479
        state->out_mem_ctx = NULL;
 
4480
 
 
4481
        /* In parameters */
 
4482
        state->orig.in.flags = _flags;
 
4483
 
 
4484
        /* Out parameters */
 
4485
        state->orig.out.numChannelPaths = _numChannelPaths;
 
4486
        state->orig.out.channelPaths = _channelPaths;
 
4487
 
 
4488
        /* Result */
 
4489
        ZERO_STRUCT(state->orig.out.result);
 
4490
 
 
4491
        state->out_mem_ctx = talloc_named_const(state, 0,
 
4492
                             "dcerpc_eventlog6_EvtRpcGetChannelList_out_memory");
 
4493
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4494
                return tevent_req_post(req, ev);
 
4495
        }
 
4496
 
 
4497
        /* make a temporary copy, that we pass to the dispatch function */
 
4498
        state->tmp = state->orig;
 
4499
 
 
4500
        subreq = dcerpc_eventlog6_EvtRpcGetChannelList_r_send(state, ev, h, &state->tmp);
 
4501
        if (tevent_req_nomem(subreq, req)) {
 
4502
                return tevent_req_post(req, ev);
 
4503
        }
 
4504
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetChannelList_done, req);
 
4505
        return req;
 
4506
}
 
4507
 
 
4508
static void dcerpc_eventlog6_EvtRpcGetChannelList_done(struct tevent_req *subreq)
 
4509
{
 
4510
        struct tevent_req *req = tevent_req_callback_data(
 
4511
                subreq, struct tevent_req);
 
4512
        struct dcerpc_eventlog6_EvtRpcGetChannelList_state *state = tevent_req_data(
 
4513
                req, struct dcerpc_eventlog6_EvtRpcGetChannelList_state);
 
4514
        NTSTATUS status;
 
4515
        TALLOC_CTX *mem_ctx;
 
4516
 
 
4517
        if (state->out_mem_ctx) {
 
4518
                mem_ctx = state->out_mem_ctx;
 
4519
        } else {
 
4520
                mem_ctx = state;
 
4521
        }
 
4522
 
 
4523
        status = dcerpc_eventlog6_EvtRpcGetChannelList_r_recv(subreq, mem_ctx);
 
4524
        TALLOC_FREE(subreq);
 
4525
        if (!NT_STATUS_IS_OK(status)) {
 
4526
                tevent_req_nterror(req, status);
 
4527
                return;
 
4528
        }
 
4529
 
 
4530
        /* Copy out parameters */
 
4531
        *state->orig.out.numChannelPaths = *state->tmp.out.numChannelPaths;
 
4532
        *state->orig.out.channelPaths = *state->tmp.out.channelPaths;
 
4533
 
 
4534
        /* Copy result */
 
4535
        state->orig.out.result = state->tmp.out.result;
 
4536
 
 
4537
        /* Reset temporary structure */
 
4538
        ZERO_STRUCT(state->tmp);
 
4539
 
 
4540
        tevent_req_done(req);
 
4541
}
 
4542
 
 
4543
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelList_recv(struct tevent_req *req,
 
4544
                                                    TALLOC_CTX *mem_ctx,
 
4545
                                                    WERROR *result)
 
4546
{
 
4547
        struct dcerpc_eventlog6_EvtRpcGetChannelList_state *state = tevent_req_data(
 
4548
                req, struct dcerpc_eventlog6_EvtRpcGetChannelList_state);
 
4549
        NTSTATUS status;
 
4550
 
 
4551
        if (tevent_req_is_nterror(req, &status)) {
 
4552
                tevent_req_received(req);
 
4553
                return status;
 
4554
        }
 
4555
 
 
4556
        /* Steal possible out parameters to the callers context */
 
4557
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4558
 
 
4559
        /* Return result */
 
4560
        *result = state->orig.out.result;
 
4561
 
 
4562
        tevent_req_received(req);
 
4563
        return NT_STATUS_OK;
 
4564
}
 
4565
 
 
4566
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelList(struct dcerpc_binding_handle *h,
 
4567
                                               TALLOC_CTX *mem_ctx,
 
4568
                                               uint32_t _flags /* [in]  */,
 
4569
                                               uint32_t *_numChannelPaths /* [out] [ref] */,
 
4570
                                               const char ***_channelPaths /* [out] [ref,range(0,MAX_RPC_CHANNEL_COUNT),charset(UTF16),size_is(,*numChannelPaths)] */,
 
4571
                                               WERROR *result)
 
4572
{
 
4573
        struct eventlog6_EvtRpcGetChannelList r;
 
4574
        NTSTATUS status;
 
4575
 
 
4576
        /* In parameters */
 
4577
        r.in.flags = _flags;
 
4578
 
 
4579
        status = dcerpc_eventlog6_EvtRpcGetChannelList_r(h, mem_ctx, &r);
 
4580
        if (!NT_STATUS_IS_OK(status)) {
 
4581
                return status;
 
4582
        }
 
4583
 
 
4584
        /* Return variables */
 
4585
        *_numChannelPaths = *r.out.numChannelPaths;
 
4586
        *_channelPaths = *r.out.channelPaths;
 
4587
 
 
4588
        /* Return result */
 
4589
        *result = r.out.result;
 
4590
 
 
4591
        return NT_STATUS_OK;
 
4592
}
 
4593
 
 
4594
struct dcerpc_eventlog6_EvtRpcGetChannelConfig_r_state {
 
4595
        TALLOC_CTX *out_mem_ctx;
 
4596
};
 
4597
 
 
4598
static void dcerpc_eventlog6_EvtRpcGetChannelConfig_r_done(struct tevent_req *subreq);
 
4599
 
 
4600
struct tevent_req *dcerpc_eventlog6_EvtRpcGetChannelConfig_r_send(TALLOC_CTX *mem_ctx,
 
4601
        struct tevent_context *ev,
 
4602
        struct dcerpc_binding_handle *h,
 
4603
        struct eventlog6_EvtRpcGetChannelConfig *r)
 
4604
{
 
4605
        struct tevent_req *req;
 
4606
        struct dcerpc_eventlog6_EvtRpcGetChannelConfig_r_state *state;
 
4607
        struct tevent_req *subreq;
 
4608
 
 
4609
        req = tevent_req_create(mem_ctx, &state,
 
4610
                                struct dcerpc_eventlog6_EvtRpcGetChannelConfig_r_state);
 
4611
        if (req == NULL) {
 
4612
                return NULL;
 
4613
        }
 
4614
 
 
4615
        state->out_mem_ctx = talloc_new(state);
 
4616
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4617
                return tevent_req_post(req, ev);
 
4618
        }
 
4619
 
 
4620
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
4621
                        NULL, &ndr_table_eventlog6,
 
4622
                        NDR_EVENTLOG6_EVTRPCGETCHANNELCONFIG, state->out_mem_ctx, r);
 
4623
        if (tevent_req_nomem(subreq, req)) {
 
4624
                return tevent_req_post(req, ev);
 
4625
        }
 
4626
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetChannelConfig_r_done, req);
 
4627
 
 
4628
        return req;
 
4629
}
 
4630
 
 
4631
static void dcerpc_eventlog6_EvtRpcGetChannelConfig_r_done(struct tevent_req *subreq)
 
4632
{
 
4633
        struct tevent_req *req =
 
4634
                tevent_req_callback_data(subreq,
 
4635
                struct tevent_req);
 
4636
        NTSTATUS status;
 
4637
 
 
4638
        status = dcerpc_binding_handle_call_recv(subreq);
 
4639
        if (!NT_STATUS_IS_OK(status)) {
 
4640
                tevent_req_nterror(req, status);
 
4641
                return;
 
4642
        }
 
4643
 
 
4644
        tevent_req_done(req);
 
4645
}
 
4646
 
 
4647
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelConfig_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
4648
{
 
4649
        struct dcerpc_eventlog6_EvtRpcGetChannelConfig_r_state *state =
 
4650
                tevent_req_data(req,
 
4651
                struct dcerpc_eventlog6_EvtRpcGetChannelConfig_r_state);
 
4652
        NTSTATUS status;
 
4653
 
 
4654
        if (tevent_req_is_nterror(req, &status)) {
 
4655
                tevent_req_received(req);
 
4656
                return status;
 
4657
        }
 
4658
 
 
4659
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4660
 
 
4661
        tevent_req_received(req);
 
4662
        return NT_STATUS_OK;
 
4663
}
 
4664
 
 
4665
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelConfig_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetChannelConfig *r)
 
4666
{
 
4667
        NTSTATUS status;
 
4668
 
 
4669
        status = dcerpc_binding_handle_call(h,
 
4670
                        NULL, &ndr_table_eventlog6,
 
4671
                        NDR_EVENTLOG6_EVTRPCGETCHANNELCONFIG, mem_ctx, r);
 
4672
 
 
4673
        return status;
 
4674
}
 
4675
 
 
4676
struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state {
 
4677
        struct eventlog6_EvtRpcGetChannelConfig orig;
 
4678
        struct eventlog6_EvtRpcGetChannelConfig tmp;
 
4679
        TALLOC_CTX *out_mem_ctx;
 
4680
};
 
4681
 
 
4682
static void dcerpc_eventlog6_EvtRpcGetChannelConfig_done(struct tevent_req *subreq);
 
4683
 
 
4684
struct tevent_req *dcerpc_eventlog6_EvtRpcGetChannelConfig_send(TALLOC_CTX *mem_ctx,
 
4685
                                                                struct tevent_context *ev,
 
4686
                                                                struct dcerpc_binding_handle *h,
 
4687
                                                                const char *_channelPath /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
4688
                                                                uint32_t _flags /* [in]  */,
 
4689
                                                                struct eventlog6_EvtRpcVariantList *_props /* [out] [ref] */)
 
4690
{
 
4691
        struct tevent_req *req;
 
4692
        struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state *state;
 
4693
        struct tevent_req *subreq;
 
4694
 
 
4695
        req = tevent_req_create(mem_ctx, &state,
 
4696
                                struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state);
 
4697
        if (req == NULL) {
 
4698
                return NULL;
 
4699
        }
 
4700
        state->out_mem_ctx = NULL;
 
4701
 
 
4702
        /* In parameters */
 
4703
        state->orig.in.channelPath = _channelPath;
 
4704
        state->orig.in.flags = _flags;
 
4705
 
 
4706
        /* Out parameters */
 
4707
        state->orig.out.props = _props;
 
4708
 
 
4709
        /* Result */
 
4710
        ZERO_STRUCT(state->orig.out.result);
 
4711
 
 
4712
        state->out_mem_ctx = talloc_named_const(state, 0,
 
4713
                             "dcerpc_eventlog6_EvtRpcGetChannelConfig_out_memory");
 
4714
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4715
                return tevent_req_post(req, ev);
 
4716
        }
 
4717
 
 
4718
        /* make a temporary copy, that we pass to the dispatch function */
 
4719
        state->tmp = state->orig;
 
4720
 
 
4721
        subreq = dcerpc_eventlog6_EvtRpcGetChannelConfig_r_send(state, ev, h, &state->tmp);
 
4722
        if (tevent_req_nomem(subreq, req)) {
 
4723
                return tevent_req_post(req, ev);
 
4724
        }
 
4725
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetChannelConfig_done, req);
 
4726
        return req;
 
4727
}
 
4728
 
 
4729
static void dcerpc_eventlog6_EvtRpcGetChannelConfig_done(struct tevent_req *subreq)
 
4730
{
 
4731
        struct tevent_req *req = tevent_req_callback_data(
 
4732
                subreq, struct tevent_req);
 
4733
        struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state *state = tevent_req_data(
 
4734
                req, struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state);
 
4735
        NTSTATUS status;
 
4736
        TALLOC_CTX *mem_ctx;
 
4737
 
 
4738
        if (state->out_mem_ctx) {
 
4739
                mem_ctx = state->out_mem_ctx;
 
4740
        } else {
 
4741
                mem_ctx = state;
 
4742
        }
 
4743
 
 
4744
        status = dcerpc_eventlog6_EvtRpcGetChannelConfig_r_recv(subreq, mem_ctx);
 
4745
        TALLOC_FREE(subreq);
 
4746
        if (!NT_STATUS_IS_OK(status)) {
 
4747
                tevent_req_nterror(req, status);
 
4748
                return;
 
4749
        }
 
4750
 
 
4751
        /* Copy out parameters */
 
4752
        *state->orig.out.props = *state->tmp.out.props;
 
4753
 
 
4754
        /* Copy result */
 
4755
        state->orig.out.result = state->tmp.out.result;
 
4756
 
 
4757
        /* Reset temporary structure */
 
4758
        ZERO_STRUCT(state->tmp);
 
4759
 
 
4760
        tevent_req_done(req);
 
4761
}
 
4762
 
 
4763
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelConfig_recv(struct tevent_req *req,
 
4764
                                                      TALLOC_CTX *mem_ctx,
 
4765
                                                      WERROR *result)
 
4766
{
 
4767
        struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state *state = tevent_req_data(
 
4768
                req, struct dcerpc_eventlog6_EvtRpcGetChannelConfig_state);
 
4769
        NTSTATUS status;
 
4770
 
 
4771
        if (tevent_req_is_nterror(req, &status)) {
 
4772
                tevent_req_received(req);
 
4773
                return status;
 
4774
        }
 
4775
 
 
4776
        /* Steal possible out parameters to the callers context */
 
4777
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4778
 
 
4779
        /* Return result */
 
4780
        *result = state->orig.out.result;
 
4781
 
 
4782
        tevent_req_received(req);
 
4783
        return NT_STATUS_OK;
 
4784
}
 
4785
 
 
4786
NTSTATUS dcerpc_eventlog6_EvtRpcGetChannelConfig(struct dcerpc_binding_handle *h,
 
4787
                                                 TALLOC_CTX *mem_ctx,
 
4788
                                                 const char *_channelPath /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
4789
                                                 uint32_t _flags /* [in]  */,
 
4790
                                                 struct eventlog6_EvtRpcVariantList *_props /* [out] [ref] */,
 
4791
                                                 WERROR *result)
 
4792
{
 
4793
        struct eventlog6_EvtRpcGetChannelConfig r;
 
4794
        NTSTATUS status;
 
4795
 
 
4796
        /* In parameters */
 
4797
        r.in.channelPath = _channelPath;
 
4798
        r.in.flags = _flags;
 
4799
 
 
4800
        status = dcerpc_eventlog6_EvtRpcGetChannelConfig_r(h, mem_ctx, &r);
 
4801
        if (!NT_STATUS_IS_OK(status)) {
 
4802
                return status;
 
4803
        }
 
4804
 
 
4805
        /* Return variables */
 
4806
        *_props = *r.out.props;
 
4807
 
 
4808
        /* Return result */
 
4809
        *result = r.out.result;
 
4810
 
 
4811
        return NT_STATUS_OK;
 
4812
}
 
4813
 
 
4814
struct dcerpc_eventlog6_EvtRpcPutChannelConfig_r_state {
 
4815
        TALLOC_CTX *out_mem_ctx;
 
4816
};
 
4817
 
 
4818
static void dcerpc_eventlog6_EvtRpcPutChannelConfig_r_done(struct tevent_req *subreq);
 
4819
 
 
4820
struct tevent_req *dcerpc_eventlog6_EvtRpcPutChannelConfig_r_send(TALLOC_CTX *mem_ctx,
 
4821
        struct tevent_context *ev,
 
4822
        struct dcerpc_binding_handle *h,
 
4823
        struct eventlog6_EvtRpcPutChannelConfig *r)
 
4824
{
 
4825
        struct tevent_req *req;
 
4826
        struct dcerpc_eventlog6_EvtRpcPutChannelConfig_r_state *state;
 
4827
        struct tevent_req *subreq;
 
4828
 
 
4829
        req = tevent_req_create(mem_ctx, &state,
 
4830
                                struct dcerpc_eventlog6_EvtRpcPutChannelConfig_r_state);
 
4831
        if (req == NULL) {
 
4832
                return NULL;
 
4833
        }
 
4834
 
 
4835
        state->out_mem_ctx = talloc_new(state);
 
4836
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4837
                return tevent_req_post(req, ev);
 
4838
        }
 
4839
 
 
4840
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
4841
                        NULL, &ndr_table_eventlog6,
 
4842
                        NDR_EVENTLOG6_EVTRPCPUTCHANNELCONFIG, state->out_mem_ctx, r);
 
4843
        if (tevent_req_nomem(subreq, req)) {
 
4844
                return tevent_req_post(req, ev);
 
4845
        }
 
4846
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcPutChannelConfig_r_done, req);
 
4847
 
 
4848
        return req;
 
4849
}
 
4850
 
 
4851
static void dcerpc_eventlog6_EvtRpcPutChannelConfig_r_done(struct tevent_req *subreq)
 
4852
{
 
4853
        struct tevent_req *req =
 
4854
                tevent_req_callback_data(subreq,
 
4855
                struct tevent_req);
 
4856
        NTSTATUS status;
 
4857
 
 
4858
        status = dcerpc_binding_handle_call_recv(subreq);
 
4859
        if (!NT_STATUS_IS_OK(status)) {
 
4860
                tevent_req_nterror(req, status);
 
4861
                return;
 
4862
        }
 
4863
 
 
4864
        tevent_req_done(req);
 
4865
}
 
4866
 
 
4867
NTSTATUS dcerpc_eventlog6_EvtRpcPutChannelConfig_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
4868
{
 
4869
        struct dcerpc_eventlog6_EvtRpcPutChannelConfig_r_state *state =
 
4870
                tevent_req_data(req,
 
4871
                struct dcerpc_eventlog6_EvtRpcPutChannelConfig_r_state);
 
4872
        NTSTATUS status;
 
4873
 
 
4874
        if (tevent_req_is_nterror(req, &status)) {
 
4875
                tevent_req_received(req);
 
4876
                return status;
 
4877
        }
 
4878
 
 
4879
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
4880
 
 
4881
        tevent_req_received(req);
 
4882
        return NT_STATUS_OK;
 
4883
}
 
4884
 
 
4885
NTSTATUS dcerpc_eventlog6_EvtRpcPutChannelConfig_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcPutChannelConfig *r)
 
4886
{
 
4887
        NTSTATUS status;
 
4888
 
 
4889
        status = dcerpc_binding_handle_call(h,
 
4890
                        NULL, &ndr_table_eventlog6,
 
4891
                        NDR_EVENTLOG6_EVTRPCPUTCHANNELCONFIG, mem_ctx, r);
 
4892
 
 
4893
        return status;
 
4894
}
 
4895
 
 
4896
struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state {
 
4897
        struct eventlog6_EvtRpcPutChannelConfig orig;
 
4898
        struct eventlog6_EvtRpcPutChannelConfig tmp;
 
4899
        TALLOC_CTX *out_mem_ctx;
 
4900
};
 
4901
 
 
4902
static void dcerpc_eventlog6_EvtRpcPutChannelConfig_done(struct tevent_req *subreq);
 
4903
 
 
4904
struct tevent_req *dcerpc_eventlog6_EvtRpcPutChannelConfig_send(TALLOC_CTX *mem_ctx,
 
4905
                                                                struct tevent_context *ev,
 
4906
                                                                struct dcerpc_binding_handle *h,
 
4907
                                                                const char *_channelPath /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
4908
                                                                uint32_t _flags /* [in]  */,
 
4909
                                                                struct eventlog6_EvtRpcVariantList *_props /* [in] [ref] */,
 
4910
                                                                struct eventlog6_RpcInfo *_error /* [out] [ref] */)
 
4911
{
 
4912
        struct tevent_req *req;
 
4913
        struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state *state;
 
4914
        struct tevent_req *subreq;
 
4915
 
 
4916
        req = tevent_req_create(mem_ctx, &state,
 
4917
                                struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state);
 
4918
        if (req == NULL) {
 
4919
                return NULL;
 
4920
        }
 
4921
        state->out_mem_ctx = NULL;
 
4922
 
 
4923
        /* In parameters */
 
4924
        state->orig.in.channelPath = _channelPath;
 
4925
        state->orig.in.flags = _flags;
 
4926
        state->orig.in.props = _props;
 
4927
 
 
4928
        /* Out parameters */
 
4929
        state->orig.out.error = _error;
 
4930
 
 
4931
        /* Result */
 
4932
        ZERO_STRUCT(state->orig.out.result);
 
4933
 
 
4934
        state->out_mem_ctx = talloc_named_const(state, 0,
 
4935
                             "dcerpc_eventlog6_EvtRpcPutChannelConfig_out_memory");
 
4936
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
4937
                return tevent_req_post(req, ev);
 
4938
        }
 
4939
 
 
4940
        /* make a temporary copy, that we pass to the dispatch function */
 
4941
        state->tmp = state->orig;
 
4942
 
 
4943
        subreq = dcerpc_eventlog6_EvtRpcPutChannelConfig_r_send(state, ev, h, &state->tmp);
 
4944
        if (tevent_req_nomem(subreq, req)) {
 
4945
                return tevent_req_post(req, ev);
 
4946
        }
 
4947
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcPutChannelConfig_done, req);
 
4948
        return req;
 
4949
}
 
4950
 
 
4951
static void dcerpc_eventlog6_EvtRpcPutChannelConfig_done(struct tevent_req *subreq)
 
4952
{
 
4953
        struct tevent_req *req = tevent_req_callback_data(
 
4954
                subreq, struct tevent_req);
 
4955
        struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state *state = tevent_req_data(
 
4956
                req, struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state);
 
4957
        NTSTATUS status;
 
4958
        TALLOC_CTX *mem_ctx;
 
4959
 
 
4960
        if (state->out_mem_ctx) {
 
4961
                mem_ctx = state->out_mem_ctx;
 
4962
        } else {
 
4963
                mem_ctx = state;
 
4964
        }
 
4965
 
 
4966
        status = dcerpc_eventlog6_EvtRpcPutChannelConfig_r_recv(subreq, mem_ctx);
 
4967
        TALLOC_FREE(subreq);
 
4968
        if (!NT_STATUS_IS_OK(status)) {
 
4969
                tevent_req_nterror(req, status);
 
4970
                return;
 
4971
        }
 
4972
 
 
4973
        /* Copy out parameters */
 
4974
        *state->orig.out.error = *state->tmp.out.error;
 
4975
 
 
4976
        /* Copy result */
 
4977
        state->orig.out.result = state->tmp.out.result;
 
4978
 
 
4979
        /* Reset temporary structure */
 
4980
        ZERO_STRUCT(state->tmp);
 
4981
 
 
4982
        tevent_req_done(req);
 
4983
}
 
4984
 
 
4985
NTSTATUS dcerpc_eventlog6_EvtRpcPutChannelConfig_recv(struct tevent_req *req,
 
4986
                                                      TALLOC_CTX *mem_ctx,
 
4987
                                                      WERROR *result)
 
4988
{
 
4989
        struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state *state = tevent_req_data(
 
4990
                req, struct dcerpc_eventlog6_EvtRpcPutChannelConfig_state);
 
4991
        NTSTATUS status;
 
4992
 
 
4993
        if (tevent_req_is_nterror(req, &status)) {
 
4994
                tevent_req_received(req);
 
4995
                return status;
 
4996
        }
 
4997
 
 
4998
        /* Steal possible out parameters to the callers context */
 
4999
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5000
 
 
5001
        /* Return result */
 
5002
        *result = state->orig.out.result;
 
5003
 
 
5004
        tevent_req_received(req);
 
5005
        return NT_STATUS_OK;
 
5006
}
 
5007
 
 
5008
NTSTATUS dcerpc_eventlog6_EvtRpcPutChannelConfig(struct dcerpc_binding_handle *h,
 
5009
                                                 TALLOC_CTX *mem_ctx,
 
5010
                                                 const char *_channelPath /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
5011
                                                 uint32_t _flags /* [in]  */,
 
5012
                                                 struct eventlog6_EvtRpcVariantList *_props /* [in] [ref] */,
 
5013
                                                 struct eventlog6_RpcInfo *_error /* [out] [ref] */,
 
5014
                                                 WERROR *result)
 
5015
{
 
5016
        struct eventlog6_EvtRpcPutChannelConfig r;
 
5017
        NTSTATUS status;
 
5018
 
 
5019
        /* In parameters */
 
5020
        r.in.channelPath = _channelPath;
 
5021
        r.in.flags = _flags;
 
5022
        r.in.props = _props;
 
5023
 
 
5024
        status = dcerpc_eventlog6_EvtRpcPutChannelConfig_r(h, mem_ctx, &r);
 
5025
        if (!NT_STATUS_IS_OK(status)) {
 
5026
                return status;
 
5027
        }
 
5028
 
 
5029
        /* Return variables */
 
5030
        *_error = *r.out.error;
 
5031
 
 
5032
        /* Return result */
 
5033
        *result = r.out.result;
 
5034
 
 
5035
        return NT_STATUS_OK;
 
5036
}
 
5037
 
 
5038
struct dcerpc_eventlog6_EvtRpcGetPublisherList_r_state {
 
5039
        TALLOC_CTX *out_mem_ctx;
 
5040
};
 
5041
 
 
5042
static void dcerpc_eventlog6_EvtRpcGetPublisherList_r_done(struct tevent_req *subreq);
 
5043
 
 
5044
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherList_r_send(TALLOC_CTX *mem_ctx,
 
5045
        struct tevent_context *ev,
 
5046
        struct dcerpc_binding_handle *h,
 
5047
        struct eventlog6_EvtRpcGetPublisherList *r)
 
5048
{
 
5049
        struct tevent_req *req;
 
5050
        struct dcerpc_eventlog6_EvtRpcGetPublisherList_r_state *state;
 
5051
        struct tevent_req *subreq;
 
5052
 
 
5053
        req = tevent_req_create(mem_ctx, &state,
 
5054
                                struct dcerpc_eventlog6_EvtRpcGetPublisherList_r_state);
 
5055
        if (req == NULL) {
 
5056
                return NULL;
 
5057
        }
 
5058
 
 
5059
        state->out_mem_ctx = talloc_new(state);
 
5060
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5061
                return tevent_req_post(req, ev);
 
5062
        }
 
5063
 
 
5064
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
5065
                        NULL, &ndr_table_eventlog6,
 
5066
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERLIST, state->out_mem_ctx, r);
 
5067
        if (tevent_req_nomem(subreq, req)) {
 
5068
                return tevent_req_post(req, ev);
 
5069
        }
 
5070
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherList_r_done, req);
 
5071
 
 
5072
        return req;
 
5073
}
 
5074
 
 
5075
static void dcerpc_eventlog6_EvtRpcGetPublisherList_r_done(struct tevent_req *subreq)
 
5076
{
 
5077
        struct tevent_req *req =
 
5078
                tevent_req_callback_data(subreq,
 
5079
                struct tevent_req);
 
5080
        NTSTATUS status;
 
5081
 
 
5082
        status = dcerpc_binding_handle_call_recv(subreq);
 
5083
        if (!NT_STATUS_IS_OK(status)) {
 
5084
                tevent_req_nterror(req, status);
 
5085
                return;
 
5086
        }
 
5087
 
 
5088
        tevent_req_done(req);
 
5089
}
 
5090
 
 
5091
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherList_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
5092
{
 
5093
        struct dcerpc_eventlog6_EvtRpcGetPublisherList_r_state *state =
 
5094
                tevent_req_data(req,
 
5095
                struct dcerpc_eventlog6_EvtRpcGetPublisherList_r_state);
 
5096
        NTSTATUS status;
 
5097
 
 
5098
        if (tevent_req_is_nterror(req, &status)) {
 
5099
                tevent_req_received(req);
 
5100
                return status;
 
5101
        }
 
5102
 
 
5103
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5104
 
 
5105
        tevent_req_received(req);
 
5106
        return NT_STATUS_OK;
 
5107
}
 
5108
 
 
5109
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherList_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetPublisherList *r)
 
5110
{
 
5111
        NTSTATUS status;
 
5112
 
 
5113
        status = dcerpc_binding_handle_call(h,
 
5114
                        NULL, &ndr_table_eventlog6,
 
5115
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERLIST, mem_ctx, r);
 
5116
 
 
5117
        return status;
 
5118
}
 
5119
 
 
5120
struct dcerpc_eventlog6_EvtRpcGetPublisherList_state {
 
5121
        struct eventlog6_EvtRpcGetPublisherList orig;
 
5122
        struct eventlog6_EvtRpcGetPublisherList tmp;
 
5123
        TALLOC_CTX *out_mem_ctx;
 
5124
};
 
5125
 
 
5126
static void dcerpc_eventlog6_EvtRpcGetPublisherList_done(struct tevent_req *subreq);
 
5127
 
 
5128
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherList_send(TALLOC_CTX *mem_ctx,
 
5129
                                                                struct tevent_context *ev,
 
5130
                                                                struct dcerpc_binding_handle *h,
 
5131
                                                                uint32_t _flags /* [in]  */,
 
5132
                                                                uint32_t *_numPublisherIds /* [out] [ref] */,
 
5133
                                                                const char ***_publisherIds /* [out] [ref,range(0,MAX_RPC_PUBLISHER_COUNT),charset(UTF16),size_is(,*numPublisherIds)] */)
 
5134
{
 
5135
        struct tevent_req *req;
 
5136
        struct dcerpc_eventlog6_EvtRpcGetPublisherList_state *state;
 
5137
        struct tevent_req *subreq;
 
5138
 
 
5139
        req = tevent_req_create(mem_ctx, &state,
 
5140
                                struct dcerpc_eventlog6_EvtRpcGetPublisherList_state);
 
5141
        if (req == NULL) {
 
5142
                return NULL;
 
5143
        }
 
5144
        state->out_mem_ctx = NULL;
 
5145
 
 
5146
        /* In parameters */
 
5147
        state->orig.in.flags = _flags;
 
5148
 
 
5149
        /* Out parameters */
 
5150
        state->orig.out.numPublisherIds = _numPublisherIds;
 
5151
        state->orig.out.publisherIds = _publisherIds;
 
5152
 
 
5153
        /* Result */
 
5154
        ZERO_STRUCT(state->orig.out.result);
 
5155
 
 
5156
        state->out_mem_ctx = talloc_named_const(state, 0,
 
5157
                             "dcerpc_eventlog6_EvtRpcGetPublisherList_out_memory");
 
5158
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5159
                return tevent_req_post(req, ev);
 
5160
        }
 
5161
 
 
5162
        /* make a temporary copy, that we pass to the dispatch function */
 
5163
        state->tmp = state->orig;
 
5164
 
 
5165
        subreq = dcerpc_eventlog6_EvtRpcGetPublisherList_r_send(state, ev, h, &state->tmp);
 
5166
        if (tevent_req_nomem(subreq, req)) {
 
5167
                return tevent_req_post(req, ev);
 
5168
        }
 
5169
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherList_done, req);
 
5170
        return req;
 
5171
}
 
5172
 
 
5173
static void dcerpc_eventlog6_EvtRpcGetPublisherList_done(struct tevent_req *subreq)
 
5174
{
 
5175
        struct tevent_req *req = tevent_req_callback_data(
 
5176
                subreq, struct tevent_req);
 
5177
        struct dcerpc_eventlog6_EvtRpcGetPublisherList_state *state = tevent_req_data(
 
5178
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherList_state);
 
5179
        NTSTATUS status;
 
5180
        TALLOC_CTX *mem_ctx;
 
5181
 
 
5182
        if (state->out_mem_ctx) {
 
5183
                mem_ctx = state->out_mem_ctx;
 
5184
        } else {
 
5185
                mem_ctx = state;
 
5186
        }
 
5187
 
 
5188
        status = dcerpc_eventlog6_EvtRpcGetPublisherList_r_recv(subreq, mem_ctx);
 
5189
        TALLOC_FREE(subreq);
 
5190
        if (!NT_STATUS_IS_OK(status)) {
 
5191
                tevent_req_nterror(req, status);
 
5192
                return;
 
5193
        }
 
5194
 
 
5195
        /* Copy out parameters */
 
5196
        *state->orig.out.numPublisherIds = *state->tmp.out.numPublisherIds;
 
5197
        *state->orig.out.publisherIds = *state->tmp.out.publisherIds;
 
5198
 
 
5199
        /* Copy result */
 
5200
        state->orig.out.result = state->tmp.out.result;
 
5201
 
 
5202
        /* Reset temporary structure */
 
5203
        ZERO_STRUCT(state->tmp);
 
5204
 
 
5205
        tevent_req_done(req);
 
5206
}
 
5207
 
 
5208
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherList_recv(struct tevent_req *req,
 
5209
                                                      TALLOC_CTX *mem_ctx,
 
5210
                                                      WERROR *result)
 
5211
{
 
5212
        struct dcerpc_eventlog6_EvtRpcGetPublisherList_state *state = tevent_req_data(
 
5213
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherList_state);
 
5214
        NTSTATUS status;
 
5215
 
 
5216
        if (tevent_req_is_nterror(req, &status)) {
 
5217
                tevent_req_received(req);
 
5218
                return status;
 
5219
        }
 
5220
 
 
5221
        /* Steal possible out parameters to the callers context */
 
5222
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5223
 
 
5224
        /* Return result */
 
5225
        *result = state->orig.out.result;
 
5226
 
 
5227
        tevent_req_received(req);
 
5228
        return NT_STATUS_OK;
 
5229
}
 
5230
 
 
5231
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherList(struct dcerpc_binding_handle *h,
 
5232
                                                 TALLOC_CTX *mem_ctx,
 
5233
                                                 uint32_t _flags /* [in]  */,
 
5234
                                                 uint32_t *_numPublisherIds /* [out] [ref] */,
 
5235
                                                 const char ***_publisherIds /* [out] [ref,range(0,MAX_RPC_PUBLISHER_COUNT),charset(UTF16),size_is(,*numPublisherIds)] */,
 
5236
                                                 WERROR *result)
 
5237
{
 
5238
        struct eventlog6_EvtRpcGetPublisherList r;
 
5239
        NTSTATUS status;
 
5240
 
 
5241
        /* In parameters */
 
5242
        r.in.flags = _flags;
 
5243
 
 
5244
        status = dcerpc_eventlog6_EvtRpcGetPublisherList_r(h, mem_ctx, &r);
 
5245
        if (!NT_STATUS_IS_OK(status)) {
 
5246
                return status;
 
5247
        }
 
5248
 
 
5249
        /* Return variables */
 
5250
        *_numPublisherIds = *r.out.numPublisherIds;
 
5251
        *_publisherIds = *r.out.publisherIds;
 
5252
 
 
5253
        /* Return result */
 
5254
        *result = r.out.result;
 
5255
 
 
5256
        return NT_STATUS_OK;
 
5257
}
 
5258
 
 
5259
struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_state {
 
5260
        TALLOC_CTX *out_mem_ctx;
 
5261
};
 
5262
 
 
5263
static void dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_done(struct tevent_req *subreq);
 
5264
 
 
5265
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_send(TALLOC_CTX *mem_ctx,
 
5266
        struct tevent_context *ev,
 
5267
        struct dcerpc_binding_handle *h,
 
5268
        struct eventlog6_EvtRpcGetPublisherListForChannel *r)
 
5269
{
 
5270
        struct tevent_req *req;
 
5271
        struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_state *state;
 
5272
        struct tevent_req *subreq;
 
5273
 
 
5274
        req = tevent_req_create(mem_ctx, &state,
 
5275
                                struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_state);
 
5276
        if (req == NULL) {
 
5277
                return NULL;
 
5278
        }
 
5279
 
 
5280
        state->out_mem_ctx = talloc_new(state);
 
5281
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5282
                return tevent_req_post(req, ev);
 
5283
        }
 
5284
 
 
5285
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
5286
                        NULL, &ndr_table_eventlog6,
 
5287
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERLISTFORCHANNEL, state->out_mem_ctx, r);
 
5288
        if (tevent_req_nomem(subreq, req)) {
 
5289
                return tevent_req_post(req, ev);
 
5290
        }
 
5291
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_done, req);
 
5292
 
 
5293
        return req;
 
5294
}
 
5295
 
 
5296
static void dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_done(struct tevent_req *subreq)
 
5297
{
 
5298
        struct tevent_req *req =
 
5299
                tevent_req_callback_data(subreq,
 
5300
                struct tevent_req);
 
5301
        NTSTATUS status;
 
5302
 
 
5303
        status = dcerpc_binding_handle_call_recv(subreq);
 
5304
        if (!NT_STATUS_IS_OK(status)) {
 
5305
                tevent_req_nterror(req, status);
 
5306
                return;
 
5307
        }
 
5308
 
 
5309
        tevent_req_done(req);
 
5310
}
 
5311
 
 
5312
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
5313
{
 
5314
        struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_state *state =
 
5315
                tevent_req_data(req,
 
5316
                struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_state);
 
5317
        NTSTATUS status;
 
5318
 
 
5319
        if (tevent_req_is_nterror(req, &status)) {
 
5320
                tevent_req_received(req);
 
5321
                return status;
 
5322
        }
 
5323
 
 
5324
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5325
 
 
5326
        tevent_req_received(req);
 
5327
        return NT_STATUS_OK;
 
5328
}
 
5329
 
 
5330
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetPublisherListForChannel *r)
 
5331
{
 
5332
        NTSTATUS status;
 
5333
 
 
5334
        status = dcerpc_binding_handle_call(h,
 
5335
                        NULL, &ndr_table_eventlog6,
 
5336
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERLISTFORCHANNEL, mem_ctx, r);
 
5337
 
 
5338
        return status;
 
5339
}
 
5340
 
 
5341
struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state {
 
5342
        struct eventlog6_EvtRpcGetPublisherListForChannel orig;
 
5343
        struct eventlog6_EvtRpcGetPublisherListForChannel tmp;
 
5344
        TALLOC_CTX *out_mem_ctx;
 
5345
};
 
5346
 
 
5347
static void dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_done(struct tevent_req *subreq);
 
5348
 
 
5349
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_send(TALLOC_CTX *mem_ctx,
 
5350
                                                                          struct tevent_context *ev,
 
5351
                                                                          struct dcerpc_binding_handle *h,
 
5352
                                                                          uint16_t *_channelName /* [in] [ref] */,
 
5353
                                                                          uint32_t _flags /* [in]  */,
 
5354
                                                                          uint32_t *_numPublisherIds /* [out] [ref] */,
 
5355
                                                                          const char ***_publisherIds /* [out] [ref,range(0,MAX_RPC_PUBLISHER_COUNT),charset(UTF16),size_is(,*numPublisherIds)] */)
 
5356
{
 
5357
        struct tevent_req *req;
 
5358
        struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state *state;
 
5359
        struct tevent_req *subreq;
 
5360
 
 
5361
        req = tevent_req_create(mem_ctx, &state,
 
5362
                                struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state);
 
5363
        if (req == NULL) {
 
5364
                return NULL;
 
5365
        }
 
5366
        state->out_mem_ctx = NULL;
 
5367
 
 
5368
        /* In parameters */
 
5369
        state->orig.in.channelName = _channelName;
 
5370
        state->orig.in.flags = _flags;
 
5371
 
 
5372
        /* Out parameters */
 
5373
        state->orig.out.numPublisherIds = _numPublisherIds;
 
5374
        state->orig.out.publisherIds = _publisherIds;
 
5375
 
 
5376
        /* Result */
 
5377
        ZERO_STRUCT(state->orig.out.result);
 
5378
 
 
5379
        state->out_mem_ctx = talloc_named_const(state, 0,
 
5380
                             "dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_out_memory");
 
5381
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5382
                return tevent_req_post(req, ev);
 
5383
        }
 
5384
 
 
5385
        /* make a temporary copy, that we pass to the dispatch function */
 
5386
        state->tmp = state->orig;
 
5387
 
 
5388
        subreq = dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_send(state, ev, h, &state->tmp);
 
5389
        if (tevent_req_nomem(subreq, req)) {
 
5390
                return tevent_req_post(req, ev);
 
5391
        }
 
5392
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_done, req);
 
5393
        return req;
 
5394
}
 
5395
 
 
5396
static void dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_done(struct tevent_req *subreq)
 
5397
{
 
5398
        struct tevent_req *req = tevent_req_callback_data(
 
5399
                subreq, struct tevent_req);
 
5400
        struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state *state = tevent_req_data(
 
5401
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state);
 
5402
        NTSTATUS status;
 
5403
        TALLOC_CTX *mem_ctx;
 
5404
 
 
5405
        if (state->out_mem_ctx) {
 
5406
                mem_ctx = state->out_mem_ctx;
 
5407
        } else {
 
5408
                mem_ctx = state;
 
5409
        }
 
5410
 
 
5411
        status = dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r_recv(subreq, mem_ctx);
 
5412
        TALLOC_FREE(subreq);
 
5413
        if (!NT_STATUS_IS_OK(status)) {
 
5414
                tevent_req_nterror(req, status);
 
5415
                return;
 
5416
        }
 
5417
 
 
5418
        /* Copy out parameters */
 
5419
        *state->orig.out.numPublisherIds = *state->tmp.out.numPublisherIds;
 
5420
        *state->orig.out.publisherIds = *state->tmp.out.publisherIds;
 
5421
 
 
5422
        /* Copy result */
 
5423
        state->orig.out.result = state->tmp.out.result;
 
5424
 
 
5425
        /* Reset temporary structure */
 
5426
        ZERO_STRUCT(state->tmp);
 
5427
 
 
5428
        tevent_req_done(req);
 
5429
}
 
5430
 
 
5431
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_recv(struct tevent_req *req,
 
5432
                                                                TALLOC_CTX *mem_ctx,
 
5433
                                                                WERROR *result)
 
5434
{
 
5435
        struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state *state = tevent_req_data(
 
5436
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_state);
 
5437
        NTSTATUS status;
 
5438
 
 
5439
        if (tevent_req_is_nterror(req, &status)) {
 
5440
                tevent_req_received(req);
 
5441
                return status;
 
5442
        }
 
5443
 
 
5444
        /* Steal possible out parameters to the callers context */
 
5445
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5446
 
 
5447
        /* Return result */
 
5448
        *result = state->orig.out.result;
 
5449
 
 
5450
        tevent_req_received(req);
 
5451
        return NT_STATUS_OK;
 
5452
}
 
5453
 
 
5454
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherListForChannel(struct dcerpc_binding_handle *h,
 
5455
                                                           TALLOC_CTX *mem_ctx,
 
5456
                                                           uint16_t *_channelName /* [in] [ref] */,
 
5457
                                                           uint32_t _flags /* [in]  */,
 
5458
                                                           uint32_t *_numPublisherIds /* [out] [ref] */,
 
5459
                                                           const char ***_publisherIds /* [out] [ref,range(0,MAX_RPC_PUBLISHER_COUNT),charset(UTF16),size_is(,*numPublisherIds)] */,
 
5460
                                                           WERROR *result)
 
5461
{
 
5462
        struct eventlog6_EvtRpcGetPublisherListForChannel r;
 
5463
        NTSTATUS status;
 
5464
 
 
5465
        /* In parameters */
 
5466
        r.in.channelName = _channelName;
 
5467
        r.in.flags = _flags;
 
5468
 
 
5469
        status = dcerpc_eventlog6_EvtRpcGetPublisherListForChannel_r(h, mem_ctx, &r);
 
5470
        if (!NT_STATUS_IS_OK(status)) {
 
5471
                return status;
 
5472
        }
 
5473
 
 
5474
        /* Return variables */
 
5475
        *_numPublisherIds = *r.out.numPublisherIds;
 
5476
        *_publisherIds = *r.out.publisherIds;
 
5477
 
 
5478
        /* Return result */
 
5479
        *result = r.out.result;
 
5480
 
 
5481
        return NT_STATUS_OK;
 
5482
}
 
5483
 
 
5484
struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_state {
 
5485
        TALLOC_CTX *out_mem_ctx;
 
5486
};
 
5487
 
 
5488
static void dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_done(struct tevent_req *subreq);
 
5489
 
 
5490
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_send(TALLOC_CTX *mem_ctx,
 
5491
        struct tevent_context *ev,
 
5492
        struct dcerpc_binding_handle *h,
 
5493
        struct eventlog6_EvtRpcGetPublisherMetadata *r)
 
5494
{
 
5495
        struct tevent_req *req;
 
5496
        struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_state *state;
 
5497
        struct tevent_req *subreq;
 
5498
 
 
5499
        req = tevent_req_create(mem_ctx, &state,
 
5500
                                struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_state);
 
5501
        if (req == NULL) {
 
5502
                return NULL;
 
5503
        }
 
5504
 
 
5505
        state->out_mem_ctx = talloc_new(state);
 
5506
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5507
                return tevent_req_post(req, ev);
 
5508
        }
 
5509
 
 
5510
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
5511
                        NULL, &ndr_table_eventlog6,
 
5512
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERMETADATA, state->out_mem_ctx, r);
 
5513
        if (tevent_req_nomem(subreq, req)) {
 
5514
                return tevent_req_post(req, ev);
 
5515
        }
 
5516
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_done, req);
 
5517
 
 
5518
        return req;
 
5519
}
 
5520
 
 
5521
static void dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_done(struct tevent_req *subreq)
 
5522
{
 
5523
        struct tevent_req *req =
 
5524
                tevent_req_callback_data(subreq,
 
5525
                struct tevent_req);
 
5526
        NTSTATUS status;
 
5527
 
 
5528
        status = dcerpc_binding_handle_call_recv(subreq);
 
5529
        if (!NT_STATUS_IS_OK(status)) {
 
5530
                tevent_req_nterror(req, status);
 
5531
                return;
 
5532
        }
 
5533
 
 
5534
        tevent_req_done(req);
 
5535
}
 
5536
 
 
5537
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
5538
{
 
5539
        struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_state *state =
 
5540
                tevent_req_data(req,
 
5541
                struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_state);
 
5542
        NTSTATUS status;
 
5543
 
 
5544
        if (tevent_req_is_nterror(req, &status)) {
 
5545
                tevent_req_received(req);
 
5546
                return status;
 
5547
        }
 
5548
 
 
5549
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5550
 
 
5551
        tevent_req_received(req);
 
5552
        return NT_STATUS_OK;
 
5553
}
 
5554
 
 
5555
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetPublisherMetadata *r)
 
5556
{
 
5557
        NTSTATUS status;
 
5558
 
 
5559
        status = dcerpc_binding_handle_call(h,
 
5560
                        NULL, &ndr_table_eventlog6,
 
5561
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERMETADATA, mem_ctx, r);
 
5562
 
 
5563
        return status;
 
5564
}
 
5565
 
 
5566
struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state {
 
5567
        struct eventlog6_EvtRpcGetPublisherMetadata orig;
 
5568
        struct eventlog6_EvtRpcGetPublisherMetadata tmp;
 
5569
        TALLOC_CTX *out_mem_ctx;
 
5570
};
 
5571
 
 
5572
static void dcerpc_eventlog6_EvtRpcGetPublisherMetadata_done(struct tevent_req *subreq);
 
5573
 
 
5574
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherMetadata_send(TALLOC_CTX *mem_ctx,
 
5575
                                                                    struct tevent_context *ev,
 
5576
                                                                    struct dcerpc_binding_handle *h,
 
5577
                                                                    const char *_publisherId /* [in] [unique,range(0,MAX_RPC_PUBLISHER_ID_LENGTH),charset(UTF16)] */,
 
5578
                                                                    const char *_logFilePath /* [in] [unique,range(0,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
5579
                                                                    uint32_t _locale /* [in]  */,
 
5580
                                                                    uint32_t _flags /* [in]  */,
 
5581
                                                                    struct eventlog6_EvtRpcVariantList *_pubMetadataProps /* [out] [ref] */,
 
5582
                                                                    struct policy_handle *_pubMetadata /* [out] [ref] */)
 
5583
{
 
5584
        struct tevent_req *req;
 
5585
        struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state *state;
 
5586
        struct tevent_req *subreq;
 
5587
 
 
5588
        req = tevent_req_create(mem_ctx, &state,
 
5589
                                struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state);
 
5590
        if (req == NULL) {
 
5591
                return NULL;
 
5592
        }
 
5593
        state->out_mem_ctx = NULL;
 
5594
 
 
5595
        /* In parameters */
 
5596
        state->orig.in.publisherId = _publisherId;
 
5597
        state->orig.in.logFilePath = _logFilePath;
 
5598
        state->orig.in.locale = _locale;
 
5599
        state->orig.in.flags = _flags;
 
5600
 
 
5601
        /* Out parameters */
 
5602
        state->orig.out.pubMetadataProps = _pubMetadataProps;
 
5603
        state->orig.out.pubMetadata = _pubMetadata;
 
5604
 
 
5605
        /* Result */
 
5606
        ZERO_STRUCT(state->orig.out.result);
 
5607
 
 
5608
        state->out_mem_ctx = talloc_named_const(state, 0,
 
5609
                             "dcerpc_eventlog6_EvtRpcGetPublisherMetadata_out_memory");
 
5610
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5611
                return tevent_req_post(req, ev);
 
5612
        }
 
5613
 
 
5614
        /* make a temporary copy, that we pass to the dispatch function */
 
5615
        state->tmp = state->orig;
 
5616
 
 
5617
        subreq = dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_send(state, ev, h, &state->tmp);
 
5618
        if (tevent_req_nomem(subreq, req)) {
 
5619
                return tevent_req_post(req, ev);
 
5620
        }
 
5621
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherMetadata_done, req);
 
5622
        return req;
 
5623
}
 
5624
 
 
5625
static void dcerpc_eventlog6_EvtRpcGetPublisherMetadata_done(struct tevent_req *subreq)
 
5626
{
 
5627
        struct tevent_req *req = tevent_req_callback_data(
 
5628
                subreq, struct tevent_req);
 
5629
        struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state *state = tevent_req_data(
 
5630
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state);
 
5631
        NTSTATUS status;
 
5632
        TALLOC_CTX *mem_ctx;
 
5633
 
 
5634
        if (state->out_mem_ctx) {
 
5635
                mem_ctx = state->out_mem_ctx;
 
5636
        } else {
 
5637
                mem_ctx = state;
 
5638
        }
 
5639
 
 
5640
        status = dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r_recv(subreq, mem_ctx);
 
5641
        TALLOC_FREE(subreq);
 
5642
        if (!NT_STATUS_IS_OK(status)) {
 
5643
                tevent_req_nterror(req, status);
 
5644
                return;
 
5645
        }
 
5646
 
 
5647
        /* Copy out parameters */
 
5648
        *state->orig.out.pubMetadataProps = *state->tmp.out.pubMetadataProps;
 
5649
        *state->orig.out.pubMetadata = *state->tmp.out.pubMetadata;
 
5650
 
 
5651
        /* Copy result */
 
5652
        state->orig.out.result = state->tmp.out.result;
 
5653
 
 
5654
        /* Reset temporary structure */
 
5655
        ZERO_STRUCT(state->tmp);
 
5656
 
 
5657
        tevent_req_done(req);
 
5658
}
 
5659
 
 
5660
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherMetadata_recv(struct tevent_req *req,
 
5661
                                                          TALLOC_CTX *mem_ctx,
 
5662
                                                          WERROR *result)
 
5663
{
 
5664
        struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state *state = tevent_req_data(
 
5665
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherMetadata_state);
 
5666
        NTSTATUS status;
 
5667
 
 
5668
        if (tevent_req_is_nterror(req, &status)) {
 
5669
                tevent_req_received(req);
 
5670
                return status;
 
5671
        }
 
5672
 
 
5673
        /* Steal possible out parameters to the callers context */
 
5674
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5675
 
 
5676
        /* Return result */
 
5677
        *result = state->orig.out.result;
 
5678
 
 
5679
        tevent_req_received(req);
 
5680
        return NT_STATUS_OK;
 
5681
}
 
5682
 
 
5683
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherMetadata(struct dcerpc_binding_handle *h,
 
5684
                                                     TALLOC_CTX *mem_ctx,
 
5685
                                                     const char *_publisherId /* [in] [unique,range(0,MAX_RPC_PUBLISHER_ID_LENGTH),charset(UTF16)] */,
 
5686
                                                     const char *_logFilePath /* [in] [unique,range(0,MAX_RPC_FILE_PATH_LENGTH),charset(UTF16)] */,
 
5687
                                                     uint32_t _locale /* [in]  */,
 
5688
                                                     uint32_t _flags /* [in]  */,
 
5689
                                                     struct eventlog6_EvtRpcVariantList *_pubMetadataProps /* [out] [ref] */,
 
5690
                                                     struct policy_handle *_pubMetadata /* [out] [ref] */,
 
5691
                                                     WERROR *result)
 
5692
{
 
5693
        struct eventlog6_EvtRpcGetPublisherMetadata r;
 
5694
        NTSTATUS status;
 
5695
 
 
5696
        /* In parameters */
 
5697
        r.in.publisherId = _publisherId;
 
5698
        r.in.logFilePath = _logFilePath;
 
5699
        r.in.locale = _locale;
 
5700
        r.in.flags = _flags;
 
5701
 
 
5702
        status = dcerpc_eventlog6_EvtRpcGetPublisherMetadata_r(h, mem_ctx, &r);
 
5703
        if (!NT_STATUS_IS_OK(status)) {
 
5704
                return status;
 
5705
        }
 
5706
 
 
5707
        /* Return variables */
 
5708
        *_pubMetadataProps = *r.out.pubMetadataProps;
 
5709
        *_pubMetadata = *r.out.pubMetadata;
 
5710
 
 
5711
        /* Return result */
 
5712
        *result = r.out.result;
 
5713
 
 
5714
        return NT_STATUS_OK;
 
5715
}
 
5716
 
 
5717
struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_state {
 
5718
        TALLOC_CTX *out_mem_ctx;
 
5719
};
 
5720
 
 
5721
static void dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_done(struct tevent_req *subreq);
 
5722
 
 
5723
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_send(TALLOC_CTX *mem_ctx,
 
5724
        struct tevent_context *ev,
 
5725
        struct dcerpc_binding_handle *h,
 
5726
        struct eventlog6_EvtRpcGetPublisherResourceMetadata *r)
 
5727
{
 
5728
        struct tevent_req *req;
 
5729
        struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_state *state;
 
5730
        struct tevent_req *subreq;
 
5731
 
 
5732
        req = tevent_req_create(mem_ctx, &state,
 
5733
                                struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_state);
 
5734
        if (req == NULL) {
 
5735
                return NULL;
 
5736
        }
 
5737
 
 
5738
        state->out_mem_ctx = talloc_new(state);
 
5739
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5740
                return tevent_req_post(req, ev);
 
5741
        }
 
5742
 
 
5743
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
5744
                        NULL, &ndr_table_eventlog6,
 
5745
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERRESOURCEMETADATA, state->out_mem_ctx, r);
 
5746
        if (tevent_req_nomem(subreq, req)) {
 
5747
                return tevent_req_post(req, ev);
 
5748
        }
 
5749
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_done, req);
 
5750
 
 
5751
        return req;
 
5752
}
 
5753
 
 
5754
static void dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_done(struct tevent_req *subreq)
 
5755
{
 
5756
        struct tevent_req *req =
 
5757
                tevent_req_callback_data(subreq,
 
5758
                struct tevent_req);
 
5759
        NTSTATUS status;
 
5760
 
 
5761
        status = dcerpc_binding_handle_call_recv(subreq);
 
5762
        if (!NT_STATUS_IS_OK(status)) {
 
5763
                tevent_req_nterror(req, status);
 
5764
                return;
 
5765
        }
 
5766
 
 
5767
        tevent_req_done(req);
 
5768
}
 
5769
 
 
5770
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
5771
{
 
5772
        struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_state *state =
 
5773
                tevent_req_data(req,
 
5774
                struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_state);
 
5775
        NTSTATUS status;
 
5776
 
 
5777
        if (tevent_req_is_nterror(req, &status)) {
 
5778
                tevent_req_received(req);
 
5779
                return status;
 
5780
        }
 
5781
 
 
5782
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5783
 
 
5784
        tevent_req_received(req);
 
5785
        return NT_STATUS_OK;
 
5786
}
 
5787
 
 
5788
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetPublisherResourceMetadata *r)
 
5789
{
 
5790
        NTSTATUS status;
 
5791
 
 
5792
        status = dcerpc_binding_handle_call(h,
 
5793
                        NULL, &ndr_table_eventlog6,
 
5794
                        NDR_EVENTLOG6_EVTRPCGETPUBLISHERRESOURCEMETADATA, mem_ctx, r);
 
5795
 
 
5796
        return status;
 
5797
}
 
5798
 
 
5799
struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state {
 
5800
        struct eventlog6_EvtRpcGetPublisherResourceMetadata orig;
 
5801
        struct eventlog6_EvtRpcGetPublisherResourceMetadata tmp;
 
5802
        TALLOC_CTX *out_mem_ctx;
 
5803
};
 
5804
 
 
5805
static void dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_done(struct tevent_req *subreq);
 
5806
 
 
5807
struct tevent_req *dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_send(TALLOC_CTX *mem_ctx,
 
5808
                                                                            struct tevent_context *ev,
 
5809
                                                                            struct dcerpc_binding_handle *h,
 
5810
                                                                            struct policy_handle *_handle /* [in] [ref] */,
 
5811
                                                                            uint32_t _propertyId /* [in]  */,
 
5812
                                                                            uint32_t _flags /* [in]  */,
 
5813
                                                                            struct eventlog6_EvtRpcVariantList *_pubMetadataProps /* [out] [ref] */)
 
5814
{
 
5815
        struct tevent_req *req;
 
5816
        struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state *state;
 
5817
        struct tevent_req *subreq;
 
5818
 
 
5819
        req = tevent_req_create(mem_ctx, &state,
 
5820
                                struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state);
 
5821
        if (req == NULL) {
 
5822
                return NULL;
 
5823
        }
 
5824
        state->out_mem_ctx = NULL;
 
5825
 
 
5826
        /* In parameters */
 
5827
        state->orig.in.handle = _handle;
 
5828
        state->orig.in.propertyId = _propertyId;
 
5829
        state->orig.in.flags = _flags;
 
5830
 
 
5831
        /* Out parameters */
 
5832
        state->orig.out.pubMetadataProps = _pubMetadataProps;
 
5833
 
 
5834
        /* Result */
 
5835
        ZERO_STRUCT(state->orig.out.result);
 
5836
 
 
5837
        state->out_mem_ctx = talloc_named_const(state, 0,
 
5838
                             "dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_out_memory");
 
5839
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5840
                return tevent_req_post(req, ev);
 
5841
        }
 
5842
 
 
5843
        /* make a temporary copy, that we pass to the dispatch function */
 
5844
        state->tmp = state->orig;
 
5845
 
 
5846
        subreq = dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_send(state, ev, h, &state->tmp);
 
5847
        if (tevent_req_nomem(subreq, req)) {
 
5848
                return tevent_req_post(req, ev);
 
5849
        }
 
5850
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_done, req);
 
5851
        return req;
 
5852
}
 
5853
 
 
5854
static void dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_done(struct tevent_req *subreq)
 
5855
{
 
5856
        struct tevent_req *req = tevent_req_callback_data(
 
5857
                subreq, struct tevent_req);
 
5858
        struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state *state = tevent_req_data(
 
5859
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state);
 
5860
        NTSTATUS status;
 
5861
        TALLOC_CTX *mem_ctx;
 
5862
 
 
5863
        if (state->out_mem_ctx) {
 
5864
                mem_ctx = state->out_mem_ctx;
 
5865
        } else {
 
5866
                mem_ctx = state;
 
5867
        }
 
5868
 
 
5869
        status = dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r_recv(subreq, mem_ctx);
 
5870
        TALLOC_FREE(subreq);
 
5871
        if (!NT_STATUS_IS_OK(status)) {
 
5872
                tevent_req_nterror(req, status);
 
5873
                return;
 
5874
        }
 
5875
 
 
5876
        /* Copy out parameters */
 
5877
        *state->orig.out.pubMetadataProps = *state->tmp.out.pubMetadataProps;
 
5878
 
 
5879
        /* Copy result */
 
5880
        state->orig.out.result = state->tmp.out.result;
 
5881
 
 
5882
        /* Reset temporary structure */
 
5883
        ZERO_STRUCT(state->tmp);
 
5884
 
 
5885
        tevent_req_done(req);
 
5886
}
 
5887
 
 
5888
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_recv(struct tevent_req *req,
 
5889
                                                                  TALLOC_CTX *mem_ctx,
 
5890
                                                                  WERROR *result)
 
5891
{
 
5892
        struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state *state = tevent_req_data(
 
5893
                req, struct dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_state);
 
5894
        NTSTATUS status;
 
5895
 
 
5896
        if (tevent_req_is_nterror(req, &status)) {
 
5897
                tevent_req_received(req);
 
5898
                return status;
 
5899
        }
 
5900
 
 
5901
        /* Steal possible out parameters to the callers context */
 
5902
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
5903
 
 
5904
        /* Return result */
 
5905
        *result = state->orig.out.result;
 
5906
 
 
5907
        tevent_req_received(req);
 
5908
        return NT_STATUS_OK;
 
5909
}
 
5910
 
 
5911
NTSTATUS dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata(struct dcerpc_binding_handle *h,
 
5912
                                                             TALLOC_CTX *mem_ctx,
 
5913
                                                             struct policy_handle *_handle /* [in] [ref] */,
 
5914
                                                             uint32_t _propertyId /* [in]  */,
 
5915
                                                             uint32_t _flags /* [in]  */,
 
5916
                                                             struct eventlog6_EvtRpcVariantList *_pubMetadataProps /* [out] [ref] */,
 
5917
                                                             WERROR *result)
 
5918
{
 
5919
        struct eventlog6_EvtRpcGetPublisherResourceMetadata r;
 
5920
        NTSTATUS status;
 
5921
 
 
5922
        /* In parameters */
 
5923
        r.in.handle = _handle;
 
5924
        r.in.propertyId = _propertyId;
 
5925
        r.in.flags = _flags;
 
5926
 
 
5927
        status = dcerpc_eventlog6_EvtRpcGetPublisherResourceMetadata_r(h, mem_ctx, &r);
 
5928
        if (!NT_STATUS_IS_OK(status)) {
 
5929
                return status;
 
5930
        }
 
5931
 
 
5932
        /* Return variables */
 
5933
        *_pubMetadataProps = *r.out.pubMetadataProps;
 
5934
 
 
5935
        /* Return result */
 
5936
        *result = r.out.result;
 
5937
 
 
5938
        return NT_STATUS_OK;
 
5939
}
 
5940
 
 
5941
struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_state {
 
5942
        TALLOC_CTX *out_mem_ctx;
 
5943
};
 
5944
 
 
5945
static void dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_done(struct tevent_req *subreq);
 
5946
 
 
5947
struct tevent_req *dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_send(TALLOC_CTX *mem_ctx,
 
5948
        struct tevent_context *ev,
 
5949
        struct dcerpc_binding_handle *h,
 
5950
        struct eventlog6_EvtRpcGetEventMetadataEnum *r)
 
5951
{
 
5952
        struct tevent_req *req;
 
5953
        struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_state *state;
 
5954
        struct tevent_req *subreq;
 
5955
 
 
5956
        req = tevent_req_create(mem_ctx, &state,
 
5957
                                struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_state);
 
5958
        if (req == NULL) {
 
5959
                return NULL;
 
5960
        }
 
5961
 
 
5962
        state->out_mem_ctx = talloc_new(state);
 
5963
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
5964
                return tevent_req_post(req, ev);
 
5965
        }
 
5966
 
 
5967
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
5968
                        NULL, &ndr_table_eventlog6,
 
5969
                        NDR_EVENTLOG6_EVTRPCGETEVENTMETADATAENUM, state->out_mem_ctx, r);
 
5970
        if (tevent_req_nomem(subreq, req)) {
 
5971
                return tevent_req_post(req, ev);
 
5972
        }
 
5973
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_done, req);
 
5974
 
 
5975
        return req;
 
5976
}
 
5977
 
 
5978
static void dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_done(struct tevent_req *subreq)
 
5979
{
 
5980
        struct tevent_req *req =
 
5981
                tevent_req_callback_data(subreq,
 
5982
                struct tevent_req);
 
5983
        NTSTATUS status;
 
5984
 
 
5985
        status = dcerpc_binding_handle_call_recv(subreq);
 
5986
        if (!NT_STATUS_IS_OK(status)) {
 
5987
                tevent_req_nterror(req, status);
 
5988
                return;
 
5989
        }
 
5990
 
 
5991
        tevent_req_done(req);
 
5992
}
 
5993
 
 
5994
NTSTATUS dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
5995
{
 
5996
        struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_state *state =
 
5997
                tevent_req_data(req,
 
5998
                struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_state);
 
5999
        NTSTATUS status;
 
6000
 
 
6001
        if (tevent_req_is_nterror(req, &status)) {
 
6002
                tevent_req_received(req);
 
6003
                return status;
 
6004
        }
 
6005
 
 
6006
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6007
 
 
6008
        tevent_req_received(req);
 
6009
        return NT_STATUS_OK;
 
6010
}
 
6011
 
 
6012
NTSTATUS dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetEventMetadataEnum *r)
 
6013
{
 
6014
        NTSTATUS status;
 
6015
 
 
6016
        status = dcerpc_binding_handle_call(h,
 
6017
                        NULL, &ndr_table_eventlog6,
 
6018
                        NDR_EVENTLOG6_EVTRPCGETEVENTMETADATAENUM, mem_ctx, r);
 
6019
 
 
6020
        return status;
 
6021
}
 
6022
 
 
6023
struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state {
 
6024
        struct eventlog6_EvtRpcGetEventMetadataEnum orig;
 
6025
        struct eventlog6_EvtRpcGetEventMetadataEnum tmp;
 
6026
        TALLOC_CTX *out_mem_ctx;
 
6027
};
 
6028
 
 
6029
static void dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_done(struct tevent_req *subreq);
 
6030
 
 
6031
struct tevent_req *dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_send(TALLOC_CTX *mem_ctx,
 
6032
                                                                    struct tevent_context *ev,
 
6033
                                                                    struct dcerpc_binding_handle *h,
 
6034
                                                                    struct policy_handle *_pubMetadata /* [in] [ref] */,
 
6035
                                                                    uint32_t _flags /* [in]  */,
 
6036
                                                                    const char *_reservedForFilter /* [in] [unique,range(0,MAX_RPC_FILTER_LENGTH),charset(UTF16)] */,
 
6037
                                                                    struct policy_handle *_eventMetaDataEnum /* [out] [ref] */)
 
6038
{
 
6039
        struct tevent_req *req;
 
6040
        struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state *state;
 
6041
        struct tevent_req *subreq;
 
6042
 
 
6043
        req = tevent_req_create(mem_ctx, &state,
 
6044
                                struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state);
 
6045
        if (req == NULL) {
 
6046
                return NULL;
 
6047
        }
 
6048
        state->out_mem_ctx = NULL;
 
6049
 
 
6050
        /* In parameters */
 
6051
        state->orig.in.pubMetadata = _pubMetadata;
 
6052
        state->orig.in.flags = _flags;
 
6053
        state->orig.in.reservedForFilter = _reservedForFilter;
 
6054
 
 
6055
        /* Out parameters */
 
6056
        state->orig.out.eventMetaDataEnum = _eventMetaDataEnum;
 
6057
 
 
6058
        /* Result */
 
6059
        ZERO_STRUCT(state->orig.out.result);
 
6060
 
 
6061
        state->out_mem_ctx = talloc_named_const(state, 0,
 
6062
                             "dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_out_memory");
 
6063
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
6064
                return tevent_req_post(req, ev);
 
6065
        }
 
6066
 
 
6067
        /* make a temporary copy, that we pass to the dispatch function */
 
6068
        state->tmp = state->orig;
 
6069
 
 
6070
        subreq = dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_send(state, ev, h, &state->tmp);
 
6071
        if (tevent_req_nomem(subreq, req)) {
 
6072
                return tevent_req_post(req, ev);
 
6073
        }
 
6074
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_done, req);
 
6075
        return req;
 
6076
}
 
6077
 
 
6078
static void dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_done(struct tevent_req *subreq)
 
6079
{
 
6080
        struct tevent_req *req = tevent_req_callback_data(
 
6081
                subreq, struct tevent_req);
 
6082
        struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state *state = tevent_req_data(
 
6083
                req, struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state);
 
6084
        NTSTATUS status;
 
6085
        TALLOC_CTX *mem_ctx;
 
6086
 
 
6087
        if (state->out_mem_ctx) {
 
6088
                mem_ctx = state->out_mem_ctx;
 
6089
        } else {
 
6090
                mem_ctx = state;
 
6091
        }
 
6092
 
 
6093
        status = dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r_recv(subreq, mem_ctx);
 
6094
        TALLOC_FREE(subreq);
 
6095
        if (!NT_STATUS_IS_OK(status)) {
 
6096
                tevent_req_nterror(req, status);
 
6097
                return;
 
6098
        }
 
6099
 
 
6100
        /* Copy out parameters */
 
6101
        *state->orig.out.eventMetaDataEnum = *state->tmp.out.eventMetaDataEnum;
 
6102
 
 
6103
        /* Copy result */
 
6104
        state->orig.out.result = state->tmp.out.result;
 
6105
 
 
6106
        /* Reset temporary structure */
 
6107
        ZERO_STRUCT(state->tmp);
 
6108
 
 
6109
        tevent_req_done(req);
 
6110
}
 
6111
 
 
6112
NTSTATUS dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_recv(struct tevent_req *req,
 
6113
                                                          TALLOC_CTX *mem_ctx,
 
6114
                                                          WERROR *result)
 
6115
{
 
6116
        struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state *state = tevent_req_data(
 
6117
                req, struct dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_state);
 
6118
        NTSTATUS status;
 
6119
 
 
6120
        if (tevent_req_is_nterror(req, &status)) {
 
6121
                tevent_req_received(req);
 
6122
                return status;
 
6123
        }
 
6124
 
 
6125
        /* Steal possible out parameters to the callers context */
 
6126
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6127
 
 
6128
        /* Return result */
 
6129
        *result = state->orig.out.result;
 
6130
 
 
6131
        tevent_req_received(req);
 
6132
        return NT_STATUS_OK;
 
6133
}
 
6134
 
 
6135
NTSTATUS dcerpc_eventlog6_EvtRpcGetEventMetadataEnum(struct dcerpc_binding_handle *h,
 
6136
                                                     TALLOC_CTX *mem_ctx,
 
6137
                                                     struct policy_handle *_pubMetadata /* [in] [ref] */,
 
6138
                                                     uint32_t _flags /* [in]  */,
 
6139
                                                     const char *_reservedForFilter /* [in] [unique,range(0,MAX_RPC_FILTER_LENGTH),charset(UTF16)] */,
 
6140
                                                     struct policy_handle *_eventMetaDataEnum /* [out] [ref] */,
 
6141
                                                     WERROR *result)
 
6142
{
 
6143
        struct eventlog6_EvtRpcGetEventMetadataEnum r;
 
6144
        NTSTATUS status;
 
6145
 
 
6146
        /* In parameters */
 
6147
        r.in.pubMetadata = _pubMetadata;
 
6148
        r.in.flags = _flags;
 
6149
        r.in.reservedForFilter = _reservedForFilter;
 
6150
 
 
6151
        status = dcerpc_eventlog6_EvtRpcGetEventMetadataEnum_r(h, mem_ctx, &r);
 
6152
        if (!NT_STATUS_IS_OK(status)) {
 
6153
                return status;
 
6154
        }
 
6155
 
 
6156
        /* Return variables */
 
6157
        *_eventMetaDataEnum = *r.out.eventMetaDataEnum;
 
6158
 
 
6159
        /* Return result */
 
6160
        *result = r.out.result;
 
6161
 
 
6162
        return NT_STATUS_OK;
 
6163
}
 
6164
 
 
6165
struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_state {
 
6166
        TALLOC_CTX *out_mem_ctx;
 
6167
};
 
6168
 
 
6169
static void dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_done(struct tevent_req *subreq);
 
6170
 
 
6171
struct tevent_req *dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_send(TALLOC_CTX *mem_ctx,
 
6172
        struct tevent_context *ev,
 
6173
        struct dcerpc_binding_handle *h,
 
6174
        struct eventlog6_EvtRpcGetNextEventMetadata *r)
 
6175
{
 
6176
        struct tevent_req *req;
 
6177
        struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_state *state;
 
6178
        struct tevent_req *subreq;
 
6179
 
 
6180
        req = tevent_req_create(mem_ctx, &state,
 
6181
                                struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_state);
 
6182
        if (req == NULL) {
 
6183
                return NULL;
 
6184
        }
 
6185
 
 
6186
        state->out_mem_ctx = talloc_new(state);
 
6187
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
6188
                return tevent_req_post(req, ev);
 
6189
        }
 
6190
 
 
6191
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
6192
                        NULL, &ndr_table_eventlog6,
 
6193
                        NDR_EVENTLOG6_EVTRPCGETNEXTEVENTMETADATA, state->out_mem_ctx, r);
 
6194
        if (tevent_req_nomem(subreq, req)) {
 
6195
                return tevent_req_post(req, ev);
 
6196
        }
 
6197
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_done, req);
 
6198
 
 
6199
        return req;
 
6200
}
 
6201
 
 
6202
static void dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_done(struct tevent_req *subreq)
 
6203
{
 
6204
        struct tevent_req *req =
 
6205
                tevent_req_callback_data(subreq,
 
6206
                struct tevent_req);
 
6207
        NTSTATUS status;
 
6208
 
 
6209
        status = dcerpc_binding_handle_call_recv(subreq);
 
6210
        if (!NT_STATUS_IS_OK(status)) {
 
6211
                tevent_req_nterror(req, status);
 
6212
                return;
 
6213
        }
 
6214
 
 
6215
        tevent_req_done(req);
 
6216
}
 
6217
 
 
6218
NTSTATUS dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
6219
{
 
6220
        struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_state *state =
 
6221
                tevent_req_data(req,
 
6222
                struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_state);
 
6223
        NTSTATUS status;
 
6224
 
 
6225
        if (tevent_req_is_nterror(req, &status)) {
 
6226
                tevent_req_received(req);
 
6227
                return status;
 
6228
        }
 
6229
 
 
6230
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6231
 
 
6232
        tevent_req_received(req);
 
6233
        return NT_STATUS_OK;
 
6234
}
 
6235
 
 
6236
NTSTATUS dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetNextEventMetadata *r)
 
6237
{
 
6238
        NTSTATUS status;
 
6239
 
 
6240
        status = dcerpc_binding_handle_call(h,
 
6241
                        NULL, &ndr_table_eventlog6,
 
6242
                        NDR_EVENTLOG6_EVTRPCGETNEXTEVENTMETADATA, mem_ctx, r);
 
6243
 
 
6244
        return status;
 
6245
}
 
6246
 
 
6247
struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state {
 
6248
        struct eventlog6_EvtRpcGetNextEventMetadata orig;
 
6249
        struct eventlog6_EvtRpcGetNextEventMetadata tmp;
 
6250
        TALLOC_CTX *out_mem_ctx;
 
6251
};
 
6252
 
 
6253
static void dcerpc_eventlog6_EvtRpcGetNextEventMetadata_done(struct tevent_req *subreq);
 
6254
 
 
6255
struct tevent_req *dcerpc_eventlog6_EvtRpcGetNextEventMetadata_send(TALLOC_CTX *mem_ctx,
 
6256
                                                                    struct tevent_context *ev,
 
6257
                                                                    struct dcerpc_binding_handle *h,
 
6258
                                                                    struct policy_handle *_eventMetaDataEnum /* [in] [ref] */,
 
6259
                                                                    uint32_t _flags /* [in]  */,
 
6260
                                                                    uint32_t _numRequested /* [in]  */,
 
6261
                                                                    uint32_t *_numReturned /* [out] [ref] */,
 
6262
                                                                    struct eventlog6_EvtRpcVariantList **_eventMetadataInstances /* [out] [ref,range(0,MAX_RPC_EVENT_METADATA_COUNT),size_is(,*numReturned)] */)
 
6263
{
 
6264
        struct tevent_req *req;
 
6265
        struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state *state;
 
6266
        struct tevent_req *subreq;
 
6267
 
 
6268
        req = tevent_req_create(mem_ctx, &state,
 
6269
                                struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state);
 
6270
        if (req == NULL) {
 
6271
                return NULL;
 
6272
        }
 
6273
        state->out_mem_ctx = NULL;
 
6274
 
 
6275
        /* In parameters */
 
6276
        state->orig.in.eventMetaDataEnum = _eventMetaDataEnum;
 
6277
        state->orig.in.flags = _flags;
 
6278
        state->orig.in.numRequested = _numRequested;
 
6279
 
 
6280
        /* Out parameters */
 
6281
        state->orig.out.numReturned = _numReturned;
 
6282
        state->orig.out.eventMetadataInstances = _eventMetadataInstances;
 
6283
 
 
6284
        /* Result */
 
6285
        ZERO_STRUCT(state->orig.out.result);
 
6286
 
 
6287
        state->out_mem_ctx = talloc_named_const(state, 0,
 
6288
                             "dcerpc_eventlog6_EvtRpcGetNextEventMetadata_out_memory");
 
6289
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
6290
                return tevent_req_post(req, ev);
 
6291
        }
 
6292
 
 
6293
        /* make a temporary copy, that we pass to the dispatch function */
 
6294
        state->tmp = state->orig;
 
6295
 
 
6296
        subreq = dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_send(state, ev, h, &state->tmp);
 
6297
        if (tevent_req_nomem(subreq, req)) {
 
6298
                return tevent_req_post(req, ev);
 
6299
        }
 
6300
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetNextEventMetadata_done, req);
 
6301
        return req;
 
6302
}
 
6303
 
 
6304
static void dcerpc_eventlog6_EvtRpcGetNextEventMetadata_done(struct tevent_req *subreq)
 
6305
{
 
6306
        struct tevent_req *req = tevent_req_callback_data(
 
6307
                subreq, struct tevent_req);
 
6308
        struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state *state = tevent_req_data(
 
6309
                req, struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state);
 
6310
        NTSTATUS status;
 
6311
        TALLOC_CTX *mem_ctx;
 
6312
 
 
6313
        if (state->out_mem_ctx) {
 
6314
                mem_ctx = state->out_mem_ctx;
 
6315
        } else {
 
6316
                mem_ctx = state;
 
6317
        }
 
6318
 
 
6319
        status = dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r_recv(subreq, mem_ctx);
 
6320
        TALLOC_FREE(subreq);
 
6321
        if (!NT_STATUS_IS_OK(status)) {
 
6322
                tevent_req_nterror(req, status);
 
6323
                return;
 
6324
        }
 
6325
 
 
6326
        /* Copy out parameters */
 
6327
        *state->orig.out.numReturned = *state->tmp.out.numReturned;
 
6328
        *state->orig.out.eventMetadataInstances = *state->tmp.out.eventMetadataInstances;
 
6329
 
 
6330
        /* Copy result */
 
6331
        state->orig.out.result = state->tmp.out.result;
 
6332
 
 
6333
        /* Reset temporary structure */
 
6334
        ZERO_STRUCT(state->tmp);
 
6335
 
 
6336
        tevent_req_done(req);
 
6337
}
 
6338
 
 
6339
NTSTATUS dcerpc_eventlog6_EvtRpcGetNextEventMetadata_recv(struct tevent_req *req,
 
6340
                                                          TALLOC_CTX *mem_ctx,
 
6341
                                                          WERROR *result)
 
6342
{
 
6343
        struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state *state = tevent_req_data(
 
6344
                req, struct dcerpc_eventlog6_EvtRpcGetNextEventMetadata_state);
 
6345
        NTSTATUS status;
 
6346
 
 
6347
        if (tevent_req_is_nterror(req, &status)) {
 
6348
                tevent_req_received(req);
 
6349
                return status;
 
6350
        }
 
6351
 
 
6352
        /* Steal possible out parameters to the callers context */
 
6353
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6354
 
 
6355
        /* Return result */
 
6356
        *result = state->orig.out.result;
 
6357
 
 
6358
        tevent_req_received(req);
 
6359
        return NT_STATUS_OK;
 
6360
}
 
6361
 
 
6362
NTSTATUS dcerpc_eventlog6_EvtRpcGetNextEventMetadata(struct dcerpc_binding_handle *h,
 
6363
                                                     TALLOC_CTX *mem_ctx,
 
6364
                                                     struct policy_handle *_eventMetaDataEnum /* [in] [ref] */,
 
6365
                                                     uint32_t _flags /* [in]  */,
 
6366
                                                     uint32_t _numRequested /* [in]  */,
 
6367
                                                     uint32_t *_numReturned /* [out] [ref] */,
 
6368
                                                     struct eventlog6_EvtRpcVariantList **_eventMetadataInstances /* [out] [ref,range(0,MAX_RPC_EVENT_METADATA_COUNT),size_is(,*numReturned)] */,
 
6369
                                                     WERROR *result)
 
6370
{
 
6371
        struct eventlog6_EvtRpcGetNextEventMetadata r;
 
6372
        NTSTATUS status;
 
6373
 
 
6374
        /* In parameters */
 
6375
        r.in.eventMetaDataEnum = _eventMetaDataEnum;
 
6376
        r.in.flags = _flags;
 
6377
        r.in.numRequested = _numRequested;
 
6378
 
 
6379
        status = dcerpc_eventlog6_EvtRpcGetNextEventMetadata_r(h, mem_ctx, &r);
 
6380
        if (!NT_STATUS_IS_OK(status)) {
 
6381
                return status;
 
6382
        }
 
6383
 
 
6384
        /* Return variables */
 
6385
        *_numReturned = *r.out.numReturned;
 
6386
        *_eventMetadataInstances = *r.out.eventMetadataInstances;
 
6387
 
 
6388
        /* Return result */
 
6389
        *result = r.out.result;
 
6390
 
 
6391
        return NT_STATUS_OK;
 
6392
}
 
6393
 
 
6394
struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_state {
 
6395
        TALLOC_CTX *out_mem_ctx;
 
6396
};
 
6397
 
 
6398
static void dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_done(struct tevent_req *subreq);
 
6399
 
 
6400
struct tevent_req *dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_send(TALLOC_CTX *mem_ctx,
 
6401
        struct tevent_context *ev,
 
6402
        struct dcerpc_binding_handle *h,
 
6403
        struct eventlog6_EvtRpcGetClassicLogDisplayName *r)
 
6404
{
 
6405
        struct tevent_req *req;
 
6406
        struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_state *state;
 
6407
        struct tevent_req *subreq;
 
6408
 
 
6409
        req = tevent_req_create(mem_ctx, &state,
 
6410
                                struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_state);
 
6411
        if (req == NULL) {
 
6412
                return NULL;
 
6413
        }
 
6414
 
 
6415
        state->out_mem_ctx = talloc_new(state);
 
6416
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
6417
                return tevent_req_post(req, ev);
 
6418
        }
 
6419
 
 
6420
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
6421
                        NULL, &ndr_table_eventlog6,
 
6422
                        NDR_EVENTLOG6_EVTRPCGETCLASSICLOGDISPLAYNAME, state->out_mem_ctx, r);
 
6423
        if (tevent_req_nomem(subreq, req)) {
 
6424
                return tevent_req_post(req, ev);
 
6425
        }
 
6426
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_done, req);
 
6427
 
 
6428
        return req;
 
6429
}
 
6430
 
 
6431
static void dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_done(struct tevent_req *subreq)
 
6432
{
 
6433
        struct tevent_req *req =
 
6434
                tevent_req_callback_data(subreq,
 
6435
                struct tevent_req);
 
6436
        NTSTATUS status;
 
6437
 
 
6438
        status = dcerpc_binding_handle_call_recv(subreq);
 
6439
        if (!NT_STATUS_IS_OK(status)) {
 
6440
                tevent_req_nterror(req, status);
 
6441
                return;
 
6442
        }
 
6443
 
 
6444
        tevent_req_done(req);
 
6445
}
 
6446
 
 
6447
NTSTATUS dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
6448
{
 
6449
        struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_state *state =
 
6450
                tevent_req_data(req,
 
6451
                struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_state);
 
6452
        NTSTATUS status;
 
6453
 
 
6454
        if (tevent_req_is_nterror(req, &status)) {
 
6455
                tevent_req_received(req);
 
6456
                return status;
 
6457
        }
 
6458
 
 
6459
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6460
 
 
6461
        tevent_req_received(req);
 
6462
        return NT_STATUS_OK;
 
6463
}
 
6464
 
 
6465
NTSTATUS dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct eventlog6_EvtRpcGetClassicLogDisplayName *r)
 
6466
{
 
6467
        NTSTATUS status;
 
6468
 
 
6469
        status = dcerpc_binding_handle_call(h,
 
6470
                        NULL, &ndr_table_eventlog6,
 
6471
                        NDR_EVENTLOG6_EVTRPCGETCLASSICLOGDISPLAYNAME, mem_ctx, r);
 
6472
 
 
6473
        return status;
 
6474
}
 
6475
 
 
6476
struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state {
 
6477
        struct eventlog6_EvtRpcGetClassicLogDisplayName orig;
 
6478
        struct eventlog6_EvtRpcGetClassicLogDisplayName tmp;
 
6479
        TALLOC_CTX *out_mem_ctx;
 
6480
};
 
6481
 
 
6482
static void dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_done(struct tevent_req *subreq);
 
6483
 
 
6484
struct tevent_req *dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_send(TALLOC_CTX *mem_ctx,
 
6485
                                                                        struct tevent_context *ev,
 
6486
                                                                        struct dcerpc_binding_handle *h,
 
6487
                                                                        const char *_logName /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
6488
                                                                        uint32_t _locale /* [in]  */,
 
6489
                                                                        uint32_t _flags /* [in]  */,
 
6490
                                                                        uint16_t **_displayName /* [out] [ref] */)
 
6491
{
 
6492
        struct tevent_req *req;
 
6493
        struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state *state;
 
6494
        struct tevent_req *subreq;
 
6495
 
 
6496
        req = tevent_req_create(mem_ctx, &state,
 
6497
                                struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state);
 
6498
        if (req == NULL) {
 
6499
                return NULL;
 
6500
        }
 
6501
        state->out_mem_ctx = NULL;
 
6502
 
 
6503
        /* In parameters */
 
6504
        state->orig.in.logName = _logName;
 
6505
        state->orig.in.locale = _locale;
 
6506
        state->orig.in.flags = _flags;
 
6507
 
 
6508
        /* Out parameters */
 
6509
        state->orig.out.displayName = _displayName;
 
6510
 
 
6511
        /* Result */
 
6512
        ZERO_STRUCT(state->orig.out.result);
 
6513
 
 
6514
        state->out_mem_ctx = talloc_named_const(state, 0,
 
6515
                             "dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_out_memory");
 
6516
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
6517
                return tevent_req_post(req, ev);
 
6518
        }
 
6519
 
 
6520
        /* make a temporary copy, that we pass to the dispatch function */
 
6521
        state->tmp = state->orig;
 
6522
 
 
6523
        subreq = dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_send(state, ev, h, &state->tmp);
 
6524
        if (tevent_req_nomem(subreq, req)) {
 
6525
                return tevent_req_post(req, ev);
 
6526
        }
 
6527
        tevent_req_set_callback(subreq, dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_done, req);
 
6528
        return req;
 
6529
}
 
6530
 
 
6531
static void dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_done(struct tevent_req *subreq)
 
6532
{
 
6533
        struct tevent_req *req = tevent_req_callback_data(
 
6534
                subreq, struct tevent_req);
 
6535
        struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state *state = tevent_req_data(
 
6536
                req, struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state);
 
6537
        NTSTATUS status;
 
6538
        TALLOC_CTX *mem_ctx;
 
6539
 
 
6540
        if (state->out_mem_ctx) {
 
6541
                mem_ctx = state->out_mem_ctx;
 
6542
        } else {
 
6543
                mem_ctx = state;
 
6544
        }
 
6545
 
 
6546
        status = dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r_recv(subreq, mem_ctx);
 
6547
        TALLOC_FREE(subreq);
 
6548
        if (!NT_STATUS_IS_OK(status)) {
 
6549
                tevent_req_nterror(req, status);
 
6550
                return;
 
6551
        }
 
6552
 
 
6553
        /* Copy out parameters */
 
6554
        *state->orig.out.displayName = *state->tmp.out.displayName;
 
6555
 
 
6556
        /* Copy result */
 
6557
        state->orig.out.result = state->tmp.out.result;
 
6558
 
 
6559
        /* Reset temporary structure */
 
6560
        ZERO_STRUCT(state->tmp);
 
6561
 
 
6562
        tevent_req_done(req);
 
6563
}
 
6564
 
 
6565
NTSTATUS dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_recv(struct tevent_req *req,
 
6566
                                                              TALLOC_CTX *mem_ctx,
 
6567
                                                              WERROR *result)
 
6568
{
 
6569
        struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state *state = tevent_req_data(
 
6570
                req, struct dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_state);
 
6571
        NTSTATUS status;
 
6572
 
 
6573
        if (tevent_req_is_nterror(req, &status)) {
 
6574
                tevent_req_received(req);
 
6575
                return status;
 
6576
        }
 
6577
 
 
6578
        /* Steal possible out parameters to the callers context */
 
6579
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
6580
 
 
6581
        /* Return result */
 
6582
        *result = state->orig.out.result;
 
6583
 
 
6584
        tevent_req_received(req);
 
6585
        return NT_STATUS_OK;
 
6586
}
 
6587
 
 
6588
NTSTATUS dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName(struct dcerpc_binding_handle *h,
 
6589
                                                         TALLOC_CTX *mem_ctx,
 
6590
                                                         const char *_logName /* [in] [ref,range(1,MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16)] */,
 
6591
                                                         uint32_t _locale /* [in]  */,
 
6592
                                                         uint32_t _flags /* [in]  */,
 
6593
                                                         uint16_t **_displayName /* [out] [ref] */,
 
6594
                                                         WERROR *result)
 
6595
{
 
6596
        struct eventlog6_EvtRpcGetClassicLogDisplayName r;
 
6597
        NTSTATUS status;
 
6598
 
 
6599
        /* In parameters */
 
6600
        r.in.logName = _logName;
 
6601
        r.in.locale = _locale;
 
6602
        r.in.flags = _flags;
 
6603
 
 
6604
        status = dcerpc_eventlog6_EvtRpcGetClassicLogDisplayName_r(h, mem_ctx, &r);
 
6605
        if (!NT_STATUS_IS_OK(status)) {
 
6606
                return status;
 
6607
        }
 
6608
 
 
6609
        /* Return variables */
 
6610
        *_displayName = *r.out.displayName;
 
6611
 
 
6612
        /* Return result */
 
6613
        *result = r.out.result;
 
6614
 
 
6615
        return NT_STATUS_OK;
 
6616
}
 
6617