← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/ndr_rap_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_rap_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_rap.h"
 
7
#include "librpc/gen_ndr/ndr_rap_c.h"
 
8
 
 
9
/* rap - client functions generated by pidl */
 
10
 
 
11
struct dcerpc_rap_NetShareEnum_r_state {
 
12
        TALLOC_CTX *out_mem_ctx;
 
13
};
 
14
 
 
15
static void dcerpc_rap_NetShareEnum_r_done(struct tevent_req *subreq);
 
16
 
 
17
struct tevent_req *dcerpc_rap_NetShareEnum_r_send(TALLOC_CTX *mem_ctx,
 
18
        struct tevent_context *ev,
 
19
        struct dcerpc_binding_handle *h,
 
20
        struct rap_NetShareEnum *r)
 
21
{
 
22
        struct tevent_req *req;
 
23
        struct dcerpc_rap_NetShareEnum_r_state *state;
 
24
        struct tevent_req *subreq;
 
25
 
 
26
        req = tevent_req_create(mem_ctx, &state,
 
27
                                struct dcerpc_rap_NetShareEnum_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_rap,
 
39
                        NDR_RAP_NETSHAREENUM, 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_rap_NetShareEnum_r_done, req);
 
44
 
 
45
        return req;
 
46
}
 
47
 
 
48
static void dcerpc_rap_NetShareEnum_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_rap_NetShareEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
65
{
 
66
        struct dcerpc_rap_NetShareEnum_r_state *state =
 
67
                tevent_req_data(req,
 
68
                struct dcerpc_rap_NetShareEnum_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_rap_NetShareEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetShareEnum *r)
 
83
{
 
84
        NTSTATUS status;
 
85
 
 
86
        status = dcerpc_binding_handle_call(h,
 
87
                        NULL, &ndr_table_rap,
 
88
                        NDR_RAP_NETSHAREENUM, mem_ctx, r);
 
89
 
 
90
        return status;
 
91
}
 
92
 
 
93
struct dcerpc_rap_NetShareAdd_r_state {
 
94
        TALLOC_CTX *out_mem_ctx;
 
95
};
 
96
 
 
97
static void dcerpc_rap_NetShareAdd_r_done(struct tevent_req *subreq);
 
98
 
 
99
struct tevent_req *dcerpc_rap_NetShareAdd_r_send(TALLOC_CTX *mem_ctx,
 
100
        struct tevent_context *ev,
 
101
        struct dcerpc_binding_handle *h,
 
102
        struct rap_NetShareAdd *r)
 
103
{
 
104
        struct tevent_req *req;
 
105
        struct dcerpc_rap_NetShareAdd_r_state *state;
 
106
        struct tevent_req *subreq;
 
107
 
 
108
        req = tevent_req_create(mem_ctx, &state,
 
109
                                struct dcerpc_rap_NetShareAdd_r_state);
 
110
        if (req == NULL) {
 
111
                return NULL;
 
112
        }
 
113
 
 
114
        state->out_mem_ctx = talloc_new(state);
 
115
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
116
                return tevent_req_post(req, ev);
 
117
        }
 
118
 
 
119
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
120
                        NULL, &ndr_table_rap,
 
121
                        NDR_RAP_NETSHAREADD, state->out_mem_ctx, r);
 
122
        if (tevent_req_nomem(subreq, req)) {
 
123
                return tevent_req_post(req, ev);
 
124
        }
 
125
        tevent_req_set_callback(subreq, dcerpc_rap_NetShareAdd_r_done, req);
 
126
 
 
127
        return req;
 
128
}
 
129
 
 
130
static void dcerpc_rap_NetShareAdd_r_done(struct tevent_req *subreq)
 
131
{
 
132
        struct tevent_req *req =
 
133
                tevent_req_callback_data(subreq,
 
134
                struct tevent_req);
 
135
        NTSTATUS status;
 
136
 
 
137
        status = dcerpc_binding_handle_call_recv(subreq);
 
138
        if (!NT_STATUS_IS_OK(status)) {
 
139
                tevent_req_nterror(req, status);
 
140
                return;
 
141
        }
 
142
 
 
143
        tevent_req_done(req);
 
144
}
 
145
 
 
146
NTSTATUS dcerpc_rap_NetShareAdd_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
147
{
 
148
        struct dcerpc_rap_NetShareAdd_r_state *state =
 
149
                tevent_req_data(req,
 
150
                struct dcerpc_rap_NetShareAdd_r_state);
 
151
        NTSTATUS status;
 
152
 
 
153
        if (tevent_req_is_nterror(req, &status)) {
 
154
                tevent_req_received(req);
 
155
                return status;
 
156
        }
 
157
 
 
158
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
159
 
 
160
        tevent_req_received(req);
 
161
        return NT_STATUS_OK;
 
162
}
 
163
 
 
164
NTSTATUS dcerpc_rap_NetShareAdd_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetShareAdd *r)
 
165
{
 
166
        NTSTATUS status;
 
167
 
 
168
        status = dcerpc_binding_handle_call(h,
 
169
                        NULL, &ndr_table_rap,
 
170
                        NDR_RAP_NETSHAREADD, mem_ctx, r);
 
171
 
 
172
        return status;
 
173
}
 
174
 
 
175
struct dcerpc_rap_NetServerEnum2_r_state {
 
176
        TALLOC_CTX *out_mem_ctx;
 
177
};
 
178
 
 
179
static void dcerpc_rap_NetServerEnum2_r_done(struct tevent_req *subreq);
 
180
 
 
181
struct tevent_req *dcerpc_rap_NetServerEnum2_r_send(TALLOC_CTX *mem_ctx,
 
182
        struct tevent_context *ev,
 
183
        struct dcerpc_binding_handle *h,
 
184
        struct rap_NetServerEnum2 *r)
 
185
{
 
186
        struct tevent_req *req;
 
187
        struct dcerpc_rap_NetServerEnum2_r_state *state;
 
188
        struct tevent_req *subreq;
 
189
 
 
190
        req = tevent_req_create(mem_ctx, &state,
 
191
                                struct dcerpc_rap_NetServerEnum2_r_state);
 
192
        if (req == NULL) {
 
193
                return NULL;
 
194
        }
 
195
 
 
196
        state->out_mem_ctx = talloc_new(state);
 
197
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
198
                return tevent_req_post(req, ev);
 
199
        }
 
200
 
 
201
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
202
                        NULL, &ndr_table_rap,
 
203
                        NDR_RAP_NETSERVERENUM2, state->out_mem_ctx, r);
 
204
        if (tevent_req_nomem(subreq, req)) {
 
205
                return tevent_req_post(req, ev);
 
206
        }
 
207
        tevent_req_set_callback(subreq, dcerpc_rap_NetServerEnum2_r_done, req);
 
208
 
 
209
        return req;
 
210
}
 
211
 
 
212
static void dcerpc_rap_NetServerEnum2_r_done(struct tevent_req *subreq)
 
213
{
 
214
        struct tevent_req *req =
 
215
                tevent_req_callback_data(subreq,
 
216
                struct tevent_req);
 
217
        NTSTATUS status;
 
218
 
 
219
        status = dcerpc_binding_handle_call_recv(subreq);
 
220
        if (!NT_STATUS_IS_OK(status)) {
 
221
                tevent_req_nterror(req, status);
 
222
                return;
 
223
        }
 
224
 
 
225
        tevent_req_done(req);
 
226
}
 
227
 
 
228
NTSTATUS dcerpc_rap_NetServerEnum2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
229
{
 
230
        struct dcerpc_rap_NetServerEnum2_r_state *state =
 
231
                tevent_req_data(req,
 
232
                struct dcerpc_rap_NetServerEnum2_r_state);
 
233
        NTSTATUS status;
 
234
 
 
235
        if (tevent_req_is_nterror(req, &status)) {
 
236
                tevent_req_received(req);
 
237
                return status;
 
238
        }
 
239
 
 
240
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
241
 
 
242
        tevent_req_received(req);
 
243
        return NT_STATUS_OK;
 
244
}
 
245
 
 
246
NTSTATUS dcerpc_rap_NetServerEnum2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetServerEnum2 *r)
 
247
{
 
248
        NTSTATUS status;
 
249
 
 
250
        status = dcerpc_binding_handle_call(h,
 
251
                        NULL, &ndr_table_rap,
 
252
                        NDR_RAP_NETSERVERENUM2, mem_ctx, r);
 
253
 
 
254
        return status;
 
255
}
 
256
 
 
257
struct dcerpc_rap_WserverGetInfo_r_state {
 
258
        TALLOC_CTX *out_mem_ctx;
 
259
};
 
260
 
 
261
static void dcerpc_rap_WserverGetInfo_r_done(struct tevent_req *subreq);
 
262
 
 
263
struct tevent_req *dcerpc_rap_WserverGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
264
        struct tevent_context *ev,
 
265
        struct dcerpc_binding_handle *h,
 
266
        struct rap_WserverGetInfo *r)
 
267
{
 
268
        struct tevent_req *req;
 
269
        struct dcerpc_rap_WserverGetInfo_r_state *state;
 
270
        struct tevent_req *subreq;
 
271
 
 
272
        req = tevent_req_create(mem_ctx, &state,
 
273
                                struct dcerpc_rap_WserverGetInfo_r_state);
 
274
        if (req == NULL) {
 
275
                return NULL;
 
276
        }
 
277
 
 
278
        state->out_mem_ctx = talloc_new(state);
 
279
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
280
                return tevent_req_post(req, ev);
 
281
        }
 
282
 
 
283
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
284
                        NULL, &ndr_table_rap,
 
285
                        NDR_RAP_WSERVERGETINFO, state->out_mem_ctx, r);
 
286
        if (tevent_req_nomem(subreq, req)) {
 
287
                return tevent_req_post(req, ev);
 
288
        }
 
289
        tevent_req_set_callback(subreq, dcerpc_rap_WserverGetInfo_r_done, req);
 
290
 
 
291
        return req;
 
292
}
 
293
 
 
294
static void dcerpc_rap_WserverGetInfo_r_done(struct tevent_req *subreq)
 
295
{
 
296
        struct tevent_req *req =
 
297
                tevent_req_callback_data(subreq,
 
298
                struct tevent_req);
 
299
        NTSTATUS status;
 
300
 
 
301
        status = dcerpc_binding_handle_call_recv(subreq);
 
302
        if (!NT_STATUS_IS_OK(status)) {
 
303
                tevent_req_nterror(req, status);
 
304
                return;
 
305
        }
 
306
 
 
307
        tevent_req_done(req);
 
308
}
 
309
 
 
310
NTSTATUS dcerpc_rap_WserverGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
311
{
 
312
        struct dcerpc_rap_WserverGetInfo_r_state *state =
 
313
                tevent_req_data(req,
 
314
                struct dcerpc_rap_WserverGetInfo_r_state);
 
315
        NTSTATUS status;
 
316
 
 
317
        if (tevent_req_is_nterror(req, &status)) {
 
318
                tevent_req_received(req);
 
319
                return status;
 
320
        }
 
321
 
 
322
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
323
 
 
324
        tevent_req_received(req);
 
325
        return NT_STATUS_OK;
 
326
}
 
327
 
 
328
NTSTATUS dcerpc_rap_WserverGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_WserverGetInfo *r)
 
329
{
 
330
        NTSTATUS status;
 
331
 
 
332
        status = dcerpc_binding_handle_call(h,
 
333
                        NULL, &ndr_table_rap,
 
334
                        NDR_RAP_WSERVERGETINFO, mem_ctx, r);
 
335
 
 
336
        return status;
 
337
}
 
338
 
 
339
struct dcerpc_rap_NetPrintQEnum_r_state {
 
340
        TALLOC_CTX *out_mem_ctx;
 
341
};
 
342
 
 
343
static void dcerpc_rap_NetPrintQEnum_r_done(struct tevent_req *subreq);
 
344
 
 
345
struct tevent_req *dcerpc_rap_NetPrintQEnum_r_send(TALLOC_CTX *mem_ctx,
 
346
        struct tevent_context *ev,
 
347
        struct dcerpc_binding_handle *h,
 
348
        struct rap_NetPrintQEnum *r)
 
349
{
 
350
        struct tevent_req *req;
 
351
        struct dcerpc_rap_NetPrintQEnum_r_state *state;
 
352
        struct tevent_req *subreq;
 
353
 
 
354
        req = tevent_req_create(mem_ctx, &state,
 
355
                                struct dcerpc_rap_NetPrintQEnum_r_state);
 
356
        if (req == NULL) {
 
357
                return NULL;
 
358
        }
 
359
 
 
360
        state->out_mem_ctx = talloc_new(state);
 
361
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
362
                return tevent_req_post(req, ev);
 
363
        }
 
364
 
 
365
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
366
                        NULL, &ndr_table_rap,
 
367
                        NDR_RAP_NETPRINTQENUM, state->out_mem_ctx, r);
 
368
        if (tevent_req_nomem(subreq, req)) {
 
369
                return tevent_req_post(req, ev);
 
370
        }
 
371
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintQEnum_r_done, req);
 
372
 
 
373
        return req;
 
374
}
 
375
 
 
376
static void dcerpc_rap_NetPrintQEnum_r_done(struct tevent_req *subreq)
 
377
{
 
378
        struct tevent_req *req =
 
379
                tevent_req_callback_data(subreq,
 
380
                struct tevent_req);
 
381
        NTSTATUS status;
 
382
 
 
383
        status = dcerpc_binding_handle_call_recv(subreq);
 
384
        if (!NT_STATUS_IS_OK(status)) {
 
385
                tevent_req_nterror(req, status);
 
386
                return;
 
387
        }
 
388
 
 
389
        tevent_req_done(req);
 
390
}
 
391
 
 
392
NTSTATUS dcerpc_rap_NetPrintQEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
393
{
 
394
        struct dcerpc_rap_NetPrintQEnum_r_state *state =
 
395
                tevent_req_data(req,
 
396
                struct dcerpc_rap_NetPrintQEnum_r_state);
 
397
        NTSTATUS status;
 
398
 
 
399
        if (tevent_req_is_nterror(req, &status)) {
 
400
                tevent_req_received(req);
 
401
                return status;
 
402
        }
 
403
 
 
404
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
405
 
 
406
        tevent_req_received(req);
 
407
        return NT_STATUS_OK;
 
408
}
 
409
 
 
410
NTSTATUS dcerpc_rap_NetPrintQEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQEnum *r)
 
411
{
 
412
        NTSTATUS status;
 
413
 
 
414
        status = dcerpc_binding_handle_call(h,
 
415
                        NULL, &ndr_table_rap,
 
416
                        NDR_RAP_NETPRINTQENUM, mem_ctx, r);
 
417
 
 
418
        return status;
 
419
}
 
420
 
 
421
struct dcerpc_rap_NetPrintQGetInfo_r_state {
 
422
        TALLOC_CTX *out_mem_ctx;
 
423
};
 
424
 
 
425
static void dcerpc_rap_NetPrintQGetInfo_r_done(struct tevent_req *subreq);
 
426
 
 
427
struct tevent_req *dcerpc_rap_NetPrintQGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
428
        struct tevent_context *ev,
 
429
        struct dcerpc_binding_handle *h,
 
430
        struct rap_NetPrintQGetInfo *r)
 
431
{
 
432
        struct tevent_req *req;
 
433
        struct dcerpc_rap_NetPrintQGetInfo_r_state *state;
 
434
        struct tevent_req *subreq;
 
435
 
 
436
        req = tevent_req_create(mem_ctx, &state,
 
437
                                struct dcerpc_rap_NetPrintQGetInfo_r_state);
 
438
        if (req == NULL) {
 
439
                return NULL;
 
440
        }
 
441
 
 
442
        state->out_mem_ctx = talloc_new(state);
 
443
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
444
                return tevent_req_post(req, ev);
 
445
        }
 
446
 
 
447
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
448
                        NULL, &ndr_table_rap,
 
449
                        NDR_RAP_NETPRINTQGETINFO, state->out_mem_ctx, r);
 
450
        if (tevent_req_nomem(subreq, req)) {
 
451
                return tevent_req_post(req, ev);
 
452
        }
 
453
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintQGetInfo_r_done, req);
 
454
 
 
455
        return req;
 
456
}
 
457
 
 
458
static void dcerpc_rap_NetPrintQGetInfo_r_done(struct tevent_req *subreq)
 
459
{
 
460
        struct tevent_req *req =
 
461
                tevent_req_callback_data(subreq,
 
462
                struct tevent_req);
 
463
        NTSTATUS status;
 
464
 
 
465
        status = dcerpc_binding_handle_call_recv(subreq);
 
466
        if (!NT_STATUS_IS_OK(status)) {
 
467
                tevent_req_nterror(req, status);
 
468
                return;
 
469
        }
 
470
 
 
471
        tevent_req_done(req);
 
472
}
 
473
 
 
474
NTSTATUS dcerpc_rap_NetPrintQGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
475
{
 
476
        struct dcerpc_rap_NetPrintQGetInfo_r_state *state =
 
477
                tevent_req_data(req,
 
478
                struct dcerpc_rap_NetPrintQGetInfo_r_state);
 
479
        NTSTATUS status;
 
480
 
 
481
        if (tevent_req_is_nterror(req, &status)) {
 
482
                tevent_req_received(req);
 
483
                return status;
 
484
        }
 
485
 
 
486
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
487
 
 
488
        tevent_req_received(req);
 
489
        return NT_STATUS_OK;
 
490
}
 
491
 
 
492
NTSTATUS dcerpc_rap_NetPrintQGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQGetInfo *r)
 
493
{
 
494
        NTSTATUS status;
 
495
 
 
496
        status = dcerpc_binding_handle_call(h,
 
497
                        NULL, &ndr_table_rap,
 
498
                        NDR_RAP_NETPRINTQGETINFO, mem_ctx, r);
 
499
 
 
500
        return status;
 
501
}
 
502
 
 
503
struct dcerpc_rap_NetPrintJobPause_r_state {
 
504
        TALLOC_CTX *out_mem_ctx;
 
505
};
 
506
 
 
507
static void dcerpc_rap_NetPrintJobPause_r_done(struct tevent_req *subreq);
 
508
 
 
509
struct tevent_req *dcerpc_rap_NetPrintJobPause_r_send(TALLOC_CTX *mem_ctx,
 
510
        struct tevent_context *ev,
 
511
        struct dcerpc_binding_handle *h,
 
512
        struct rap_NetPrintJobPause *r)
 
513
{
 
514
        struct tevent_req *req;
 
515
        struct dcerpc_rap_NetPrintJobPause_r_state *state;
 
516
        struct tevent_req *subreq;
 
517
 
 
518
        req = tevent_req_create(mem_ctx, &state,
 
519
                                struct dcerpc_rap_NetPrintJobPause_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_rap,
 
531
                        NDR_RAP_NETPRINTJOBPAUSE, 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_rap_NetPrintJobPause_r_done, req);
 
536
 
 
537
        return req;
 
538
}
 
539
 
 
540
static void dcerpc_rap_NetPrintJobPause_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_rap_NetPrintJobPause_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
557
{
 
558
        struct dcerpc_rap_NetPrintJobPause_r_state *state =
 
559
                tevent_req_data(req,
 
560
                struct dcerpc_rap_NetPrintJobPause_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_rap_NetPrintJobPause_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobPause *r)
 
575
{
 
576
        NTSTATUS status;
 
577
 
 
578
        status = dcerpc_binding_handle_call(h,
 
579
                        NULL, &ndr_table_rap,
 
580
                        NDR_RAP_NETPRINTJOBPAUSE, mem_ctx, r);
 
581
 
 
582
        return status;
 
583
}
 
584
 
 
585
struct dcerpc_rap_NetPrintJobContinue_r_state {
 
586
        TALLOC_CTX *out_mem_ctx;
 
587
};
 
588
 
 
589
static void dcerpc_rap_NetPrintJobContinue_r_done(struct tevent_req *subreq);
 
590
 
 
591
struct tevent_req *dcerpc_rap_NetPrintJobContinue_r_send(TALLOC_CTX *mem_ctx,
 
592
        struct tevent_context *ev,
 
593
        struct dcerpc_binding_handle *h,
 
594
        struct rap_NetPrintJobContinue *r)
 
595
{
 
596
        struct tevent_req *req;
 
597
        struct dcerpc_rap_NetPrintJobContinue_r_state *state;
 
598
        struct tevent_req *subreq;
 
599
 
 
600
        req = tevent_req_create(mem_ctx, &state,
 
601
                                struct dcerpc_rap_NetPrintJobContinue_r_state);
 
602
        if (req == NULL) {
 
603
                return NULL;
 
604
        }
 
605
 
 
606
        state->out_mem_ctx = talloc_new(state);
 
607
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
608
                return tevent_req_post(req, ev);
 
609
        }
 
610
 
 
611
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
612
                        NULL, &ndr_table_rap,
 
613
                        NDR_RAP_NETPRINTJOBCONTINUE, state->out_mem_ctx, r);
 
614
        if (tevent_req_nomem(subreq, req)) {
 
615
                return tevent_req_post(req, ev);
 
616
        }
 
617
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintJobContinue_r_done, req);
 
618
 
 
619
        return req;
 
620
}
 
621
 
 
622
static void dcerpc_rap_NetPrintJobContinue_r_done(struct tevent_req *subreq)
 
623
{
 
624
        struct tevent_req *req =
 
625
                tevent_req_callback_data(subreq,
 
626
                struct tevent_req);
 
627
        NTSTATUS status;
 
628
 
 
629
        status = dcerpc_binding_handle_call_recv(subreq);
 
630
        if (!NT_STATUS_IS_OK(status)) {
 
631
                tevent_req_nterror(req, status);
 
632
                return;
 
633
        }
 
634
 
 
635
        tevent_req_done(req);
 
636
}
 
637
 
 
638
NTSTATUS dcerpc_rap_NetPrintJobContinue_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
639
{
 
640
        struct dcerpc_rap_NetPrintJobContinue_r_state *state =
 
641
                tevent_req_data(req,
 
642
                struct dcerpc_rap_NetPrintJobContinue_r_state);
 
643
        NTSTATUS status;
 
644
 
 
645
        if (tevent_req_is_nterror(req, &status)) {
 
646
                tevent_req_received(req);
 
647
                return status;
 
648
        }
 
649
 
 
650
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
651
 
 
652
        tevent_req_received(req);
 
653
        return NT_STATUS_OK;
 
654
}
 
655
 
 
656
NTSTATUS dcerpc_rap_NetPrintJobContinue_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobContinue *r)
 
657
{
 
658
        NTSTATUS status;
 
659
 
 
660
        status = dcerpc_binding_handle_call(h,
 
661
                        NULL, &ndr_table_rap,
 
662
                        NDR_RAP_NETPRINTJOBCONTINUE, mem_ctx, r);
 
663
 
 
664
        return status;
 
665
}
 
666
 
 
667
struct dcerpc_rap_NetPrintJobDelete_r_state {
 
668
        TALLOC_CTX *out_mem_ctx;
 
669
};
 
670
 
 
671
static void dcerpc_rap_NetPrintJobDelete_r_done(struct tevent_req *subreq);
 
672
 
 
673
struct tevent_req *dcerpc_rap_NetPrintJobDelete_r_send(TALLOC_CTX *mem_ctx,
 
674
        struct tevent_context *ev,
 
675
        struct dcerpc_binding_handle *h,
 
676
        struct rap_NetPrintJobDelete *r)
 
677
{
 
678
        struct tevent_req *req;
 
679
        struct dcerpc_rap_NetPrintJobDelete_r_state *state;
 
680
        struct tevent_req *subreq;
 
681
 
 
682
        req = tevent_req_create(mem_ctx, &state,
 
683
                                struct dcerpc_rap_NetPrintJobDelete_r_state);
 
684
        if (req == NULL) {
 
685
                return NULL;
 
686
        }
 
687
 
 
688
        state->out_mem_ctx = talloc_new(state);
 
689
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
690
                return tevent_req_post(req, ev);
 
691
        }
 
692
 
 
693
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
694
                        NULL, &ndr_table_rap,
 
695
                        NDR_RAP_NETPRINTJOBDELETE, state->out_mem_ctx, r);
 
696
        if (tevent_req_nomem(subreq, req)) {
 
697
                return tevent_req_post(req, ev);
 
698
        }
 
699
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintJobDelete_r_done, req);
 
700
 
 
701
        return req;
 
702
}
 
703
 
 
704
static void dcerpc_rap_NetPrintJobDelete_r_done(struct tevent_req *subreq)
 
705
{
 
706
        struct tevent_req *req =
 
707
                tevent_req_callback_data(subreq,
 
708
                struct tevent_req);
 
709
        NTSTATUS status;
 
710
 
 
711
        status = dcerpc_binding_handle_call_recv(subreq);
 
712
        if (!NT_STATUS_IS_OK(status)) {
 
713
                tevent_req_nterror(req, status);
 
714
                return;
 
715
        }
 
716
 
 
717
        tevent_req_done(req);
 
718
}
 
719
 
 
720
NTSTATUS dcerpc_rap_NetPrintJobDelete_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
721
{
 
722
        struct dcerpc_rap_NetPrintJobDelete_r_state *state =
 
723
                tevent_req_data(req,
 
724
                struct dcerpc_rap_NetPrintJobDelete_r_state);
 
725
        NTSTATUS status;
 
726
 
 
727
        if (tevent_req_is_nterror(req, &status)) {
 
728
                tevent_req_received(req);
 
729
                return status;
 
730
        }
 
731
 
 
732
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
733
 
 
734
        tevent_req_received(req);
 
735
        return NT_STATUS_OK;
 
736
}
 
737
 
 
738
NTSTATUS dcerpc_rap_NetPrintJobDelete_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobDelete *r)
 
739
{
 
740
        NTSTATUS status;
 
741
 
 
742
        status = dcerpc_binding_handle_call(h,
 
743
                        NULL, &ndr_table_rap,
 
744
                        NDR_RAP_NETPRINTJOBDELETE, mem_ctx, r);
 
745
 
 
746
        return status;
 
747
}
 
748
 
 
749
struct dcerpc_rap_NetPrintQueuePause_r_state {
 
750
        TALLOC_CTX *out_mem_ctx;
 
751
};
 
752
 
 
753
static void dcerpc_rap_NetPrintQueuePause_r_done(struct tevent_req *subreq);
 
754
 
 
755
struct tevent_req *dcerpc_rap_NetPrintQueuePause_r_send(TALLOC_CTX *mem_ctx,
 
756
        struct tevent_context *ev,
 
757
        struct dcerpc_binding_handle *h,
 
758
        struct rap_NetPrintQueuePause *r)
 
759
{
 
760
        struct tevent_req *req;
 
761
        struct dcerpc_rap_NetPrintQueuePause_r_state *state;
 
762
        struct tevent_req *subreq;
 
763
 
 
764
        req = tevent_req_create(mem_ctx, &state,
 
765
                                struct dcerpc_rap_NetPrintQueuePause_r_state);
 
766
        if (req == NULL) {
 
767
                return NULL;
 
768
        }
 
769
 
 
770
        state->out_mem_ctx = talloc_new(state);
 
771
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
772
                return tevent_req_post(req, ev);
 
773
        }
 
774
 
 
775
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
776
                        NULL, &ndr_table_rap,
 
777
                        NDR_RAP_NETPRINTQUEUEPAUSE, state->out_mem_ctx, r);
 
778
        if (tevent_req_nomem(subreq, req)) {
 
779
                return tevent_req_post(req, ev);
 
780
        }
 
781
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintQueuePause_r_done, req);
 
782
 
 
783
        return req;
 
784
}
 
785
 
 
786
static void dcerpc_rap_NetPrintQueuePause_r_done(struct tevent_req *subreq)
 
787
{
 
788
        struct tevent_req *req =
 
789
                tevent_req_callback_data(subreq,
 
790
                struct tevent_req);
 
791
        NTSTATUS status;
 
792
 
 
793
        status = dcerpc_binding_handle_call_recv(subreq);
 
794
        if (!NT_STATUS_IS_OK(status)) {
 
795
                tevent_req_nterror(req, status);
 
796
                return;
 
797
        }
 
798
 
 
799
        tevent_req_done(req);
 
800
}
 
801
 
 
802
NTSTATUS dcerpc_rap_NetPrintQueuePause_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
803
{
 
804
        struct dcerpc_rap_NetPrintQueuePause_r_state *state =
 
805
                tevent_req_data(req,
 
806
                struct dcerpc_rap_NetPrintQueuePause_r_state);
 
807
        NTSTATUS status;
 
808
 
 
809
        if (tevent_req_is_nterror(req, &status)) {
 
810
                tevent_req_received(req);
 
811
                return status;
 
812
        }
 
813
 
 
814
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
815
 
 
816
        tevent_req_received(req);
 
817
        return NT_STATUS_OK;
 
818
}
 
819
 
 
820
NTSTATUS dcerpc_rap_NetPrintQueuePause_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQueuePause *r)
 
821
{
 
822
        NTSTATUS status;
 
823
 
 
824
        status = dcerpc_binding_handle_call(h,
 
825
                        NULL, &ndr_table_rap,
 
826
                        NDR_RAP_NETPRINTQUEUEPAUSE, mem_ctx, r);
 
827
 
 
828
        return status;
 
829
}
 
830
 
 
831
struct dcerpc_rap_NetPrintQueueResume_r_state {
 
832
        TALLOC_CTX *out_mem_ctx;
 
833
};
 
834
 
 
835
static void dcerpc_rap_NetPrintQueueResume_r_done(struct tevent_req *subreq);
 
836
 
 
837
struct tevent_req *dcerpc_rap_NetPrintQueueResume_r_send(TALLOC_CTX *mem_ctx,
 
838
        struct tevent_context *ev,
 
839
        struct dcerpc_binding_handle *h,
 
840
        struct rap_NetPrintQueueResume *r)
 
841
{
 
842
        struct tevent_req *req;
 
843
        struct dcerpc_rap_NetPrintQueueResume_r_state *state;
 
844
        struct tevent_req *subreq;
 
845
 
 
846
        req = tevent_req_create(mem_ctx, &state,
 
847
                                struct dcerpc_rap_NetPrintQueueResume_r_state);
 
848
        if (req == NULL) {
 
849
                return NULL;
 
850
        }
 
851
 
 
852
        state->out_mem_ctx = talloc_new(state);
 
853
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
854
                return tevent_req_post(req, ev);
 
855
        }
 
856
 
 
857
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
858
                        NULL, &ndr_table_rap,
 
859
                        NDR_RAP_NETPRINTQUEUERESUME, state->out_mem_ctx, r);
 
860
        if (tevent_req_nomem(subreq, req)) {
 
861
                return tevent_req_post(req, ev);
 
862
        }
 
863
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintQueueResume_r_done, req);
 
864
 
 
865
        return req;
 
866
}
 
867
 
 
868
static void dcerpc_rap_NetPrintQueueResume_r_done(struct tevent_req *subreq)
 
869
{
 
870
        struct tevent_req *req =
 
871
                tevent_req_callback_data(subreq,
 
872
                struct tevent_req);
 
873
        NTSTATUS status;
 
874
 
 
875
        status = dcerpc_binding_handle_call_recv(subreq);
 
876
        if (!NT_STATUS_IS_OK(status)) {
 
877
                tevent_req_nterror(req, status);
 
878
                return;
 
879
        }
 
880
 
 
881
        tevent_req_done(req);
 
882
}
 
883
 
 
884
NTSTATUS dcerpc_rap_NetPrintQueueResume_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
885
{
 
886
        struct dcerpc_rap_NetPrintQueueResume_r_state *state =
 
887
                tevent_req_data(req,
 
888
                struct dcerpc_rap_NetPrintQueueResume_r_state);
 
889
        NTSTATUS status;
 
890
 
 
891
        if (tevent_req_is_nterror(req, &status)) {
 
892
                tevent_req_received(req);
 
893
                return status;
 
894
        }
 
895
 
 
896
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
897
 
 
898
        tevent_req_received(req);
 
899
        return NT_STATUS_OK;
 
900
}
 
901
 
 
902
NTSTATUS dcerpc_rap_NetPrintQueueResume_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQueueResume *r)
 
903
{
 
904
        NTSTATUS status;
 
905
 
 
906
        status = dcerpc_binding_handle_call(h,
 
907
                        NULL, &ndr_table_rap,
 
908
                        NDR_RAP_NETPRINTQUEUERESUME, mem_ctx, r);
 
909
 
 
910
        return status;
 
911
}
 
912
 
 
913
struct dcerpc_rap_NetPrintQueuePurge_r_state {
 
914
        TALLOC_CTX *out_mem_ctx;
 
915
};
 
916
 
 
917
static void dcerpc_rap_NetPrintQueuePurge_r_done(struct tevent_req *subreq);
 
918
 
 
919
struct tevent_req *dcerpc_rap_NetPrintQueuePurge_r_send(TALLOC_CTX *mem_ctx,
 
920
        struct tevent_context *ev,
 
921
        struct dcerpc_binding_handle *h,
 
922
        struct rap_NetPrintQueuePurge *r)
 
923
{
 
924
        struct tevent_req *req;
 
925
        struct dcerpc_rap_NetPrintQueuePurge_r_state *state;
 
926
        struct tevent_req *subreq;
 
927
 
 
928
        req = tevent_req_create(mem_ctx, &state,
 
929
                                struct dcerpc_rap_NetPrintQueuePurge_r_state);
 
930
        if (req == NULL) {
 
931
                return NULL;
 
932
        }
 
933
 
 
934
        state->out_mem_ctx = talloc_new(state);
 
935
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
936
                return tevent_req_post(req, ev);
 
937
        }
 
938
 
 
939
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
940
                        NULL, &ndr_table_rap,
 
941
                        NDR_RAP_NETPRINTQUEUEPURGE, state->out_mem_ctx, r);
 
942
        if (tevent_req_nomem(subreq, req)) {
 
943
                return tevent_req_post(req, ev);
 
944
        }
 
945
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintQueuePurge_r_done, req);
 
946
 
 
947
        return req;
 
948
}
 
949
 
 
950
static void dcerpc_rap_NetPrintQueuePurge_r_done(struct tevent_req *subreq)
 
951
{
 
952
        struct tevent_req *req =
 
953
                tevent_req_callback_data(subreq,
 
954
                struct tevent_req);
 
955
        NTSTATUS status;
 
956
 
 
957
        status = dcerpc_binding_handle_call_recv(subreq);
 
958
        if (!NT_STATUS_IS_OK(status)) {
 
959
                tevent_req_nterror(req, status);
 
960
                return;
 
961
        }
 
962
 
 
963
        tevent_req_done(req);
 
964
}
 
965
 
 
966
NTSTATUS dcerpc_rap_NetPrintQueuePurge_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
967
{
 
968
        struct dcerpc_rap_NetPrintQueuePurge_r_state *state =
 
969
                tevent_req_data(req,
 
970
                struct dcerpc_rap_NetPrintQueuePurge_r_state);
 
971
        NTSTATUS status;
 
972
 
 
973
        if (tevent_req_is_nterror(req, &status)) {
 
974
                tevent_req_received(req);
 
975
                return status;
 
976
        }
 
977
 
 
978
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
979
 
 
980
        tevent_req_received(req);
 
981
        return NT_STATUS_OK;
 
982
}
 
983
 
 
984
NTSTATUS dcerpc_rap_NetPrintQueuePurge_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQueuePurge *r)
 
985
{
 
986
        NTSTATUS status;
 
987
 
 
988
        status = dcerpc_binding_handle_call(h,
 
989
                        NULL, &ndr_table_rap,
 
990
                        NDR_RAP_NETPRINTQUEUEPURGE, mem_ctx, r);
 
991
 
 
992
        return status;
 
993
}
 
994
 
 
995
struct dcerpc_rap_NetPrintJobEnum_r_state {
 
996
        TALLOC_CTX *out_mem_ctx;
 
997
};
 
998
 
 
999
static void dcerpc_rap_NetPrintJobEnum_r_done(struct tevent_req *subreq);
 
1000
 
 
1001
struct tevent_req *dcerpc_rap_NetPrintJobEnum_r_send(TALLOC_CTX *mem_ctx,
 
1002
        struct tevent_context *ev,
 
1003
        struct dcerpc_binding_handle *h,
 
1004
        struct rap_NetPrintJobEnum *r)
 
1005
{
 
1006
        struct tevent_req *req;
 
1007
        struct dcerpc_rap_NetPrintJobEnum_r_state *state;
 
1008
        struct tevent_req *subreq;
 
1009
 
 
1010
        req = tevent_req_create(mem_ctx, &state,
 
1011
                                struct dcerpc_rap_NetPrintJobEnum_r_state);
 
1012
        if (req == NULL) {
 
1013
                return NULL;
 
1014
        }
 
1015
 
 
1016
        state->out_mem_ctx = talloc_new(state);
 
1017
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1018
                return tevent_req_post(req, ev);
 
1019
        }
 
1020
 
 
1021
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1022
                        NULL, &ndr_table_rap,
 
1023
                        NDR_RAP_NETPRINTJOBENUM, state->out_mem_ctx, r);
 
1024
        if (tevent_req_nomem(subreq, req)) {
 
1025
                return tevent_req_post(req, ev);
 
1026
        }
 
1027
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintJobEnum_r_done, req);
 
1028
 
 
1029
        return req;
 
1030
}
 
1031
 
 
1032
static void dcerpc_rap_NetPrintJobEnum_r_done(struct tevent_req *subreq)
 
1033
{
 
1034
        struct tevent_req *req =
 
1035
                tevent_req_callback_data(subreq,
 
1036
                struct tevent_req);
 
1037
        NTSTATUS status;
 
1038
 
 
1039
        status = dcerpc_binding_handle_call_recv(subreq);
 
1040
        if (!NT_STATUS_IS_OK(status)) {
 
1041
                tevent_req_nterror(req, status);
 
1042
                return;
 
1043
        }
 
1044
 
 
1045
        tevent_req_done(req);
 
1046
}
 
1047
 
 
1048
NTSTATUS dcerpc_rap_NetPrintJobEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1049
{
 
1050
        struct dcerpc_rap_NetPrintJobEnum_r_state *state =
 
1051
                tevent_req_data(req,
 
1052
                struct dcerpc_rap_NetPrintJobEnum_r_state);
 
1053
        NTSTATUS status;
 
1054
 
 
1055
        if (tevent_req_is_nterror(req, &status)) {
 
1056
                tevent_req_received(req);
 
1057
                return status;
 
1058
        }
 
1059
 
 
1060
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1061
 
 
1062
        tevent_req_received(req);
 
1063
        return NT_STATUS_OK;
 
1064
}
 
1065
 
 
1066
NTSTATUS dcerpc_rap_NetPrintJobEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobEnum *r)
 
1067
{
 
1068
        NTSTATUS status;
 
1069
 
 
1070
        status = dcerpc_binding_handle_call(h,
 
1071
                        NULL, &ndr_table_rap,
 
1072
                        NDR_RAP_NETPRINTJOBENUM, mem_ctx, r);
 
1073
 
 
1074
        return status;
 
1075
}
 
1076
 
 
1077
struct dcerpc_rap_NetPrintJobGetInfo_r_state {
 
1078
        TALLOC_CTX *out_mem_ctx;
 
1079
};
 
1080
 
 
1081
static void dcerpc_rap_NetPrintJobGetInfo_r_done(struct tevent_req *subreq);
 
1082
 
 
1083
struct tevent_req *dcerpc_rap_NetPrintJobGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
1084
        struct tevent_context *ev,
 
1085
        struct dcerpc_binding_handle *h,
 
1086
        struct rap_NetPrintJobGetInfo *r)
 
1087
{
 
1088
        struct tevent_req *req;
 
1089
        struct dcerpc_rap_NetPrintJobGetInfo_r_state *state;
 
1090
        struct tevent_req *subreq;
 
1091
 
 
1092
        req = tevent_req_create(mem_ctx, &state,
 
1093
                                struct dcerpc_rap_NetPrintJobGetInfo_r_state);
 
1094
        if (req == NULL) {
 
1095
                return NULL;
 
1096
        }
 
1097
 
 
1098
        state->out_mem_ctx = talloc_new(state);
 
1099
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1100
                return tevent_req_post(req, ev);
 
1101
        }
 
1102
 
 
1103
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1104
                        NULL, &ndr_table_rap,
 
1105
                        NDR_RAP_NETPRINTJOBGETINFO, state->out_mem_ctx, r);
 
1106
        if (tevent_req_nomem(subreq, req)) {
 
1107
                return tevent_req_post(req, ev);
 
1108
        }
 
1109
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintJobGetInfo_r_done, req);
 
1110
 
 
1111
        return req;
 
1112
}
 
1113
 
 
1114
static void dcerpc_rap_NetPrintJobGetInfo_r_done(struct tevent_req *subreq)
 
1115
{
 
1116
        struct tevent_req *req =
 
1117
                tevent_req_callback_data(subreq,
 
1118
                struct tevent_req);
 
1119
        NTSTATUS status;
 
1120
 
 
1121
        status = dcerpc_binding_handle_call_recv(subreq);
 
1122
        if (!NT_STATUS_IS_OK(status)) {
 
1123
                tevent_req_nterror(req, status);
 
1124
                return;
 
1125
        }
 
1126
 
 
1127
        tevent_req_done(req);
 
1128
}
 
1129
 
 
1130
NTSTATUS dcerpc_rap_NetPrintJobGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1131
{
 
1132
        struct dcerpc_rap_NetPrintJobGetInfo_r_state *state =
 
1133
                tevent_req_data(req,
 
1134
                struct dcerpc_rap_NetPrintJobGetInfo_r_state);
 
1135
        NTSTATUS status;
 
1136
 
 
1137
        if (tevent_req_is_nterror(req, &status)) {
 
1138
                tevent_req_received(req);
 
1139
                return status;
 
1140
        }
 
1141
 
 
1142
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1143
 
 
1144
        tevent_req_received(req);
 
1145
        return NT_STATUS_OK;
 
1146
}
 
1147
 
 
1148
NTSTATUS dcerpc_rap_NetPrintJobGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobGetInfo *r)
 
1149
{
 
1150
        NTSTATUS status;
 
1151
 
 
1152
        status = dcerpc_binding_handle_call(h,
 
1153
                        NULL, &ndr_table_rap,
 
1154
                        NDR_RAP_NETPRINTJOBGETINFO, mem_ctx, r);
 
1155
 
 
1156
        return status;
 
1157
}
 
1158
 
 
1159
struct dcerpc_rap_NetPrintJobSetInfo_r_state {
 
1160
        TALLOC_CTX *out_mem_ctx;
 
1161
};
 
1162
 
 
1163
static void dcerpc_rap_NetPrintJobSetInfo_r_done(struct tevent_req *subreq);
 
1164
 
 
1165
struct tevent_req *dcerpc_rap_NetPrintJobSetInfo_r_send(TALLOC_CTX *mem_ctx,
 
1166
        struct tevent_context *ev,
 
1167
        struct dcerpc_binding_handle *h,
 
1168
        struct rap_NetPrintJobSetInfo *r)
 
1169
{
 
1170
        struct tevent_req *req;
 
1171
        struct dcerpc_rap_NetPrintJobSetInfo_r_state *state;
 
1172
        struct tevent_req *subreq;
 
1173
 
 
1174
        req = tevent_req_create(mem_ctx, &state,
 
1175
                                struct dcerpc_rap_NetPrintJobSetInfo_r_state);
 
1176
        if (req == NULL) {
 
1177
                return NULL;
 
1178
        }
 
1179
 
 
1180
        state->out_mem_ctx = talloc_new(state);
 
1181
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1182
                return tevent_req_post(req, ev);
 
1183
        }
 
1184
 
 
1185
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1186
                        NULL, &ndr_table_rap,
 
1187
                        NDR_RAP_NETPRINTJOBSETINFO, state->out_mem_ctx, r);
 
1188
        if (tevent_req_nomem(subreq, req)) {
 
1189
                return tevent_req_post(req, ev);
 
1190
        }
 
1191
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintJobSetInfo_r_done, req);
 
1192
 
 
1193
        return req;
 
1194
}
 
1195
 
 
1196
static void dcerpc_rap_NetPrintJobSetInfo_r_done(struct tevent_req *subreq)
 
1197
{
 
1198
        struct tevent_req *req =
 
1199
                tevent_req_callback_data(subreq,
 
1200
                struct tevent_req);
 
1201
        NTSTATUS status;
 
1202
 
 
1203
        status = dcerpc_binding_handle_call_recv(subreq);
 
1204
        if (!NT_STATUS_IS_OK(status)) {
 
1205
                tevent_req_nterror(req, status);
 
1206
                return;
 
1207
        }
 
1208
 
 
1209
        tevent_req_done(req);
 
1210
}
 
1211
 
 
1212
NTSTATUS dcerpc_rap_NetPrintJobSetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1213
{
 
1214
        struct dcerpc_rap_NetPrintJobSetInfo_r_state *state =
 
1215
                tevent_req_data(req,
 
1216
                struct dcerpc_rap_NetPrintJobSetInfo_r_state);
 
1217
        NTSTATUS status;
 
1218
 
 
1219
        if (tevent_req_is_nterror(req, &status)) {
 
1220
                tevent_req_received(req);
 
1221
                return status;
 
1222
        }
 
1223
 
 
1224
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1225
 
 
1226
        tevent_req_received(req);
 
1227
        return NT_STATUS_OK;
 
1228
}
 
1229
 
 
1230
NTSTATUS dcerpc_rap_NetPrintJobSetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintJobSetInfo *r)
 
1231
{
 
1232
        NTSTATUS status;
 
1233
 
 
1234
        status = dcerpc_binding_handle_call(h,
 
1235
                        NULL, &ndr_table_rap,
 
1236
                        NDR_RAP_NETPRINTJOBSETINFO, mem_ctx, r);
 
1237
 
 
1238
        return status;
 
1239
}
 
1240
 
 
1241
struct dcerpc_rap_NetPrintDestEnum_r_state {
 
1242
        TALLOC_CTX *out_mem_ctx;
 
1243
};
 
1244
 
 
1245
static void dcerpc_rap_NetPrintDestEnum_r_done(struct tevent_req *subreq);
 
1246
 
 
1247
struct tevent_req *dcerpc_rap_NetPrintDestEnum_r_send(TALLOC_CTX *mem_ctx,
 
1248
        struct tevent_context *ev,
 
1249
        struct dcerpc_binding_handle *h,
 
1250
        struct rap_NetPrintDestEnum *r)
 
1251
{
 
1252
        struct tevent_req *req;
 
1253
        struct dcerpc_rap_NetPrintDestEnum_r_state *state;
 
1254
        struct tevent_req *subreq;
 
1255
 
 
1256
        req = tevent_req_create(mem_ctx, &state,
 
1257
                                struct dcerpc_rap_NetPrintDestEnum_r_state);
 
1258
        if (req == NULL) {
 
1259
                return NULL;
 
1260
        }
 
1261
 
 
1262
        state->out_mem_ctx = talloc_new(state);
 
1263
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1264
                return tevent_req_post(req, ev);
 
1265
        }
 
1266
 
 
1267
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1268
                        NULL, &ndr_table_rap,
 
1269
                        NDR_RAP_NETPRINTDESTENUM, state->out_mem_ctx, r);
 
1270
        if (tevent_req_nomem(subreq, req)) {
 
1271
                return tevent_req_post(req, ev);
 
1272
        }
 
1273
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintDestEnum_r_done, req);
 
1274
 
 
1275
        return req;
 
1276
}
 
1277
 
 
1278
static void dcerpc_rap_NetPrintDestEnum_r_done(struct tevent_req *subreq)
 
1279
{
 
1280
        struct tevent_req *req =
 
1281
                tevent_req_callback_data(subreq,
 
1282
                struct tevent_req);
 
1283
        NTSTATUS status;
 
1284
 
 
1285
        status = dcerpc_binding_handle_call_recv(subreq);
 
1286
        if (!NT_STATUS_IS_OK(status)) {
 
1287
                tevent_req_nterror(req, status);
 
1288
                return;
 
1289
        }
 
1290
 
 
1291
        tevent_req_done(req);
 
1292
}
 
1293
 
 
1294
NTSTATUS dcerpc_rap_NetPrintDestEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1295
{
 
1296
        struct dcerpc_rap_NetPrintDestEnum_r_state *state =
 
1297
                tevent_req_data(req,
 
1298
                struct dcerpc_rap_NetPrintDestEnum_r_state);
 
1299
        NTSTATUS status;
 
1300
 
 
1301
        if (tevent_req_is_nterror(req, &status)) {
 
1302
                tevent_req_received(req);
 
1303
                return status;
 
1304
        }
 
1305
 
 
1306
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1307
 
 
1308
        tevent_req_received(req);
 
1309
        return NT_STATUS_OK;
 
1310
}
 
1311
 
 
1312
NTSTATUS dcerpc_rap_NetPrintDestEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintDestEnum *r)
 
1313
{
 
1314
        NTSTATUS status;
 
1315
 
 
1316
        status = dcerpc_binding_handle_call(h,
 
1317
                        NULL, &ndr_table_rap,
 
1318
                        NDR_RAP_NETPRINTDESTENUM, mem_ctx, r);
 
1319
 
 
1320
        return status;
 
1321
}
 
1322
 
 
1323
struct dcerpc_rap_NetPrintDestGetInfo_r_state {
 
1324
        TALLOC_CTX *out_mem_ctx;
 
1325
};
 
1326
 
 
1327
static void dcerpc_rap_NetPrintDestGetInfo_r_done(struct tevent_req *subreq);
 
1328
 
 
1329
struct tevent_req *dcerpc_rap_NetPrintDestGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
1330
        struct tevent_context *ev,
 
1331
        struct dcerpc_binding_handle *h,
 
1332
        struct rap_NetPrintDestGetInfo *r)
 
1333
{
 
1334
        struct tevent_req *req;
 
1335
        struct dcerpc_rap_NetPrintDestGetInfo_r_state *state;
 
1336
        struct tevent_req *subreq;
 
1337
 
 
1338
        req = tevent_req_create(mem_ctx, &state,
 
1339
                                struct dcerpc_rap_NetPrintDestGetInfo_r_state);
 
1340
        if (req == NULL) {
 
1341
                return NULL;
 
1342
        }
 
1343
 
 
1344
        state->out_mem_ctx = talloc_new(state);
 
1345
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1346
                return tevent_req_post(req, ev);
 
1347
        }
 
1348
 
 
1349
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1350
                        NULL, &ndr_table_rap,
 
1351
                        NDR_RAP_NETPRINTDESTGETINFO, state->out_mem_ctx, r);
 
1352
        if (tevent_req_nomem(subreq, req)) {
 
1353
                return tevent_req_post(req, ev);
 
1354
        }
 
1355
        tevent_req_set_callback(subreq, dcerpc_rap_NetPrintDestGetInfo_r_done, req);
 
1356
 
 
1357
        return req;
 
1358
}
 
1359
 
 
1360
static void dcerpc_rap_NetPrintDestGetInfo_r_done(struct tevent_req *subreq)
 
1361
{
 
1362
        struct tevent_req *req =
 
1363
                tevent_req_callback_data(subreq,
 
1364
                struct tevent_req);
 
1365
        NTSTATUS status;
 
1366
 
 
1367
        status = dcerpc_binding_handle_call_recv(subreq);
 
1368
        if (!NT_STATUS_IS_OK(status)) {
 
1369
                tevent_req_nterror(req, status);
 
1370
                return;
 
1371
        }
 
1372
 
 
1373
        tevent_req_done(req);
 
1374
}
 
1375
 
 
1376
NTSTATUS dcerpc_rap_NetPrintDestGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1377
{
 
1378
        struct dcerpc_rap_NetPrintDestGetInfo_r_state *state =
 
1379
                tevent_req_data(req,
 
1380
                struct dcerpc_rap_NetPrintDestGetInfo_r_state);
 
1381
        NTSTATUS status;
 
1382
 
 
1383
        if (tevent_req_is_nterror(req, &status)) {
 
1384
                tevent_req_received(req);
 
1385
                return status;
 
1386
        }
 
1387
 
 
1388
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1389
 
 
1390
        tevent_req_received(req);
 
1391
        return NT_STATUS_OK;
 
1392
}
 
1393
 
 
1394
NTSTATUS dcerpc_rap_NetPrintDestGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintDestGetInfo *r)
 
1395
{
 
1396
        NTSTATUS status;
 
1397
 
 
1398
        status = dcerpc_binding_handle_call(h,
 
1399
                        NULL, &ndr_table_rap,
 
1400
                        NDR_RAP_NETPRINTDESTGETINFO, mem_ctx, r);
 
1401
 
 
1402
        return status;
 
1403
}
 
1404
 
 
1405
struct dcerpc_rap_NetUserPasswordSet2_r_state {
 
1406
        TALLOC_CTX *out_mem_ctx;
 
1407
};
 
1408
 
 
1409
static void dcerpc_rap_NetUserPasswordSet2_r_done(struct tevent_req *subreq);
 
1410
 
 
1411
struct tevent_req *dcerpc_rap_NetUserPasswordSet2_r_send(TALLOC_CTX *mem_ctx,
 
1412
        struct tevent_context *ev,
 
1413
        struct dcerpc_binding_handle *h,
 
1414
        struct rap_NetUserPasswordSet2 *r)
 
1415
{
 
1416
        struct tevent_req *req;
 
1417
        struct dcerpc_rap_NetUserPasswordSet2_r_state *state;
 
1418
        struct tevent_req *subreq;
 
1419
 
 
1420
        req = tevent_req_create(mem_ctx, &state,
 
1421
                                struct dcerpc_rap_NetUserPasswordSet2_r_state);
 
1422
        if (req == NULL) {
 
1423
                return NULL;
 
1424
        }
 
1425
 
 
1426
        state->out_mem_ctx = talloc_new(state);
 
1427
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1428
                return tevent_req_post(req, ev);
 
1429
        }
 
1430
 
 
1431
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1432
                        NULL, &ndr_table_rap,
 
1433
                        NDR_RAP_NETUSERPASSWORDSET2, state->out_mem_ctx, r);
 
1434
        if (tevent_req_nomem(subreq, req)) {
 
1435
                return tevent_req_post(req, ev);
 
1436
        }
 
1437
        tevent_req_set_callback(subreq, dcerpc_rap_NetUserPasswordSet2_r_done, req);
 
1438
 
 
1439
        return req;
 
1440
}
 
1441
 
 
1442
static void dcerpc_rap_NetUserPasswordSet2_r_done(struct tevent_req *subreq)
 
1443
{
 
1444
        struct tevent_req *req =
 
1445
                tevent_req_callback_data(subreq,
 
1446
                struct tevent_req);
 
1447
        NTSTATUS status;
 
1448
 
 
1449
        status = dcerpc_binding_handle_call_recv(subreq);
 
1450
        if (!NT_STATUS_IS_OK(status)) {
 
1451
                tevent_req_nterror(req, status);
 
1452
                return;
 
1453
        }
 
1454
 
 
1455
        tevent_req_done(req);
 
1456
}
 
1457
 
 
1458
NTSTATUS dcerpc_rap_NetUserPasswordSet2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1459
{
 
1460
        struct dcerpc_rap_NetUserPasswordSet2_r_state *state =
 
1461
                tevent_req_data(req,
 
1462
                struct dcerpc_rap_NetUserPasswordSet2_r_state);
 
1463
        NTSTATUS status;
 
1464
 
 
1465
        if (tevent_req_is_nterror(req, &status)) {
 
1466
                tevent_req_received(req);
 
1467
                return status;
 
1468
        }
 
1469
 
 
1470
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1471
 
 
1472
        tevent_req_received(req);
 
1473
        return NT_STATUS_OK;
 
1474
}
 
1475
 
 
1476
NTSTATUS dcerpc_rap_NetUserPasswordSet2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetUserPasswordSet2 *r)
 
1477
{
 
1478
        NTSTATUS status;
 
1479
 
 
1480
        status = dcerpc_binding_handle_call(h,
 
1481
                        NULL, &ndr_table_rap,
 
1482
                        NDR_RAP_NETUSERPASSWORDSET2, mem_ctx, r);
 
1483
 
 
1484
        return status;
 
1485
}
 
1486
 
 
1487
struct dcerpc_rap_NetOEMChangePassword_r_state {
 
1488
        TALLOC_CTX *out_mem_ctx;
 
1489
};
 
1490
 
 
1491
static void dcerpc_rap_NetOEMChangePassword_r_done(struct tevent_req *subreq);
 
1492
 
 
1493
struct tevent_req *dcerpc_rap_NetOEMChangePassword_r_send(TALLOC_CTX *mem_ctx,
 
1494
        struct tevent_context *ev,
 
1495
        struct dcerpc_binding_handle *h,
 
1496
        struct rap_NetOEMChangePassword *r)
 
1497
{
 
1498
        struct tevent_req *req;
 
1499
        struct dcerpc_rap_NetOEMChangePassword_r_state *state;
 
1500
        struct tevent_req *subreq;
 
1501
 
 
1502
        req = tevent_req_create(mem_ctx, &state,
 
1503
                                struct dcerpc_rap_NetOEMChangePassword_r_state);
 
1504
        if (req == NULL) {
 
1505
                return NULL;
 
1506
        }
 
1507
 
 
1508
        state->out_mem_ctx = talloc_new(state);
 
1509
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1510
                return tevent_req_post(req, ev);
 
1511
        }
 
1512
 
 
1513
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1514
                        NULL, &ndr_table_rap,
 
1515
                        NDR_RAP_NETOEMCHANGEPASSWORD, state->out_mem_ctx, r);
 
1516
        if (tevent_req_nomem(subreq, req)) {
 
1517
                return tevent_req_post(req, ev);
 
1518
        }
 
1519
        tevent_req_set_callback(subreq, dcerpc_rap_NetOEMChangePassword_r_done, req);
 
1520
 
 
1521
        return req;
 
1522
}
 
1523
 
 
1524
static void dcerpc_rap_NetOEMChangePassword_r_done(struct tevent_req *subreq)
 
1525
{
 
1526
        struct tevent_req *req =
 
1527
                tevent_req_callback_data(subreq,
 
1528
                struct tevent_req);
 
1529
        NTSTATUS status;
 
1530
 
 
1531
        status = dcerpc_binding_handle_call_recv(subreq);
 
1532
        if (!NT_STATUS_IS_OK(status)) {
 
1533
                tevent_req_nterror(req, status);
 
1534
                return;
 
1535
        }
 
1536
 
 
1537
        tevent_req_done(req);
 
1538
}
 
1539
 
 
1540
NTSTATUS dcerpc_rap_NetOEMChangePassword_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1541
{
 
1542
        struct dcerpc_rap_NetOEMChangePassword_r_state *state =
 
1543
                tevent_req_data(req,
 
1544
                struct dcerpc_rap_NetOEMChangePassword_r_state);
 
1545
        NTSTATUS status;
 
1546
 
 
1547
        if (tevent_req_is_nterror(req, &status)) {
 
1548
                tevent_req_received(req);
 
1549
                return status;
 
1550
        }
 
1551
 
 
1552
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1553
 
 
1554
        tevent_req_received(req);
 
1555
        return NT_STATUS_OK;
 
1556
}
 
1557
 
 
1558
NTSTATUS dcerpc_rap_NetOEMChangePassword_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetOEMChangePassword *r)
 
1559
{
 
1560
        NTSTATUS status;
 
1561
 
 
1562
        status = dcerpc_binding_handle_call(h,
 
1563
                        NULL, &ndr_table_rap,
 
1564
                        NDR_RAP_NETOEMCHANGEPASSWORD, mem_ctx, r);
 
1565
 
 
1566
        return status;
 
1567
}
 
1568
 
 
1569
struct dcerpc_rap_NetUserGetInfo_r_state {
 
1570
        TALLOC_CTX *out_mem_ctx;
 
1571
};
 
1572
 
 
1573
static void dcerpc_rap_NetUserGetInfo_r_done(struct tevent_req *subreq);
 
1574
 
 
1575
struct tevent_req *dcerpc_rap_NetUserGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
1576
        struct tevent_context *ev,
 
1577
        struct dcerpc_binding_handle *h,
 
1578
        struct rap_NetUserGetInfo *r)
 
1579
{
 
1580
        struct tevent_req *req;
 
1581
        struct dcerpc_rap_NetUserGetInfo_r_state *state;
 
1582
        struct tevent_req *subreq;
 
1583
 
 
1584
        req = tevent_req_create(mem_ctx, &state,
 
1585
                                struct dcerpc_rap_NetUserGetInfo_r_state);
 
1586
        if (req == NULL) {
 
1587
                return NULL;
 
1588
        }
 
1589
 
 
1590
        state->out_mem_ctx = talloc_new(state);
 
1591
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1592
                return tevent_req_post(req, ev);
 
1593
        }
 
1594
 
 
1595
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1596
                        NULL, &ndr_table_rap,
 
1597
                        NDR_RAP_NETUSERGETINFO, state->out_mem_ctx, r);
 
1598
        if (tevent_req_nomem(subreq, req)) {
 
1599
                return tevent_req_post(req, ev);
 
1600
        }
 
1601
        tevent_req_set_callback(subreq, dcerpc_rap_NetUserGetInfo_r_done, req);
 
1602
 
 
1603
        return req;
 
1604
}
 
1605
 
 
1606
static void dcerpc_rap_NetUserGetInfo_r_done(struct tevent_req *subreq)
 
1607
{
 
1608
        struct tevent_req *req =
 
1609
                tevent_req_callback_data(subreq,
 
1610
                struct tevent_req);
 
1611
        NTSTATUS status;
 
1612
 
 
1613
        status = dcerpc_binding_handle_call_recv(subreq);
 
1614
        if (!NT_STATUS_IS_OK(status)) {
 
1615
                tevent_req_nterror(req, status);
 
1616
                return;
 
1617
        }
 
1618
 
 
1619
        tevent_req_done(req);
 
1620
}
 
1621
 
 
1622
NTSTATUS dcerpc_rap_NetUserGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1623
{
 
1624
        struct dcerpc_rap_NetUserGetInfo_r_state *state =
 
1625
                tevent_req_data(req,
 
1626
                struct dcerpc_rap_NetUserGetInfo_r_state);
 
1627
        NTSTATUS status;
 
1628
 
 
1629
        if (tevent_req_is_nterror(req, &status)) {
 
1630
                tevent_req_received(req);
 
1631
                return status;
 
1632
        }
 
1633
 
 
1634
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1635
 
 
1636
        tevent_req_received(req);
 
1637
        return NT_STATUS_OK;
 
1638
}
 
1639
 
 
1640
NTSTATUS dcerpc_rap_NetUserGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetUserGetInfo *r)
 
1641
{
 
1642
        NTSTATUS status;
 
1643
 
 
1644
        status = dcerpc_binding_handle_call(h,
 
1645
                        NULL, &ndr_table_rap,
 
1646
                        NDR_RAP_NETUSERGETINFO, mem_ctx, r);
 
1647
 
 
1648
        return status;
 
1649
}
 
1650
 
 
1651
struct dcerpc_rap_NetSessionEnum_r_state {
 
1652
        TALLOC_CTX *out_mem_ctx;
 
1653
};
 
1654
 
 
1655
static void dcerpc_rap_NetSessionEnum_r_done(struct tevent_req *subreq);
 
1656
 
 
1657
struct tevent_req *dcerpc_rap_NetSessionEnum_r_send(TALLOC_CTX *mem_ctx,
 
1658
        struct tevent_context *ev,
 
1659
        struct dcerpc_binding_handle *h,
 
1660
        struct rap_NetSessionEnum *r)
 
1661
{
 
1662
        struct tevent_req *req;
 
1663
        struct dcerpc_rap_NetSessionEnum_r_state *state;
 
1664
        struct tevent_req *subreq;
 
1665
 
 
1666
        req = tevent_req_create(mem_ctx, &state,
 
1667
                                struct dcerpc_rap_NetSessionEnum_r_state);
 
1668
        if (req == NULL) {
 
1669
                return NULL;
 
1670
        }
 
1671
 
 
1672
        state->out_mem_ctx = talloc_new(state);
 
1673
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1674
                return tevent_req_post(req, ev);
 
1675
        }
 
1676
 
 
1677
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1678
                        NULL, &ndr_table_rap,
 
1679
                        NDR_RAP_NETSESSIONENUM, state->out_mem_ctx, r);
 
1680
        if (tevent_req_nomem(subreq, req)) {
 
1681
                return tevent_req_post(req, ev);
 
1682
        }
 
1683
        tevent_req_set_callback(subreq, dcerpc_rap_NetSessionEnum_r_done, req);
 
1684
 
 
1685
        return req;
 
1686
}
 
1687
 
 
1688
static void dcerpc_rap_NetSessionEnum_r_done(struct tevent_req *subreq)
 
1689
{
 
1690
        struct tevent_req *req =
 
1691
                tevent_req_callback_data(subreq,
 
1692
                struct tevent_req);
 
1693
        NTSTATUS status;
 
1694
 
 
1695
        status = dcerpc_binding_handle_call_recv(subreq);
 
1696
        if (!NT_STATUS_IS_OK(status)) {
 
1697
                tevent_req_nterror(req, status);
 
1698
                return;
 
1699
        }
 
1700
 
 
1701
        tevent_req_done(req);
 
1702
}
 
1703
 
 
1704
NTSTATUS dcerpc_rap_NetSessionEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1705
{
 
1706
        struct dcerpc_rap_NetSessionEnum_r_state *state =
 
1707
                tevent_req_data(req,
 
1708
                struct dcerpc_rap_NetSessionEnum_r_state);
 
1709
        NTSTATUS status;
 
1710
 
 
1711
        if (tevent_req_is_nterror(req, &status)) {
 
1712
                tevent_req_received(req);
 
1713
                return status;
 
1714
        }
 
1715
 
 
1716
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1717
 
 
1718
        tevent_req_received(req);
 
1719
        return NT_STATUS_OK;
 
1720
}
 
1721
 
 
1722
NTSTATUS dcerpc_rap_NetSessionEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetSessionEnum *r)
 
1723
{
 
1724
        NTSTATUS status;
 
1725
 
 
1726
        status = dcerpc_binding_handle_call(h,
 
1727
                        NULL, &ndr_table_rap,
 
1728
                        NDR_RAP_NETSESSIONENUM, mem_ctx, r);
 
1729
 
 
1730
        return status;
 
1731
}
 
1732
 
 
1733
struct dcerpc_rap_NetSessionGetInfo_r_state {
 
1734
        TALLOC_CTX *out_mem_ctx;
 
1735
};
 
1736
 
 
1737
static void dcerpc_rap_NetSessionGetInfo_r_done(struct tevent_req *subreq);
 
1738
 
 
1739
struct tevent_req *dcerpc_rap_NetSessionGetInfo_r_send(TALLOC_CTX *mem_ctx,
 
1740
        struct tevent_context *ev,
 
1741
        struct dcerpc_binding_handle *h,
 
1742
        struct rap_NetSessionGetInfo *r)
 
1743
{
 
1744
        struct tevent_req *req;
 
1745
        struct dcerpc_rap_NetSessionGetInfo_r_state *state;
 
1746
        struct tevent_req *subreq;
 
1747
 
 
1748
        req = tevent_req_create(mem_ctx, &state,
 
1749
                                struct dcerpc_rap_NetSessionGetInfo_r_state);
 
1750
        if (req == NULL) {
 
1751
                return NULL;
 
1752
        }
 
1753
 
 
1754
        state->out_mem_ctx = talloc_new(state);
 
1755
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1756
                return tevent_req_post(req, ev);
 
1757
        }
 
1758
 
 
1759
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1760
                        NULL, &ndr_table_rap,
 
1761
                        NDR_RAP_NETSESSIONGETINFO, state->out_mem_ctx, r);
 
1762
        if (tevent_req_nomem(subreq, req)) {
 
1763
                return tevent_req_post(req, ev);
 
1764
        }
 
1765
        tevent_req_set_callback(subreq, dcerpc_rap_NetSessionGetInfo_r_done, req);
 
1766
 
 
1767
        return req;
 
1768
}
 
1769
 
 
1770
static void dcerpc_rap_NetSessionGetInfo_r_done(struct tevent_req *subreq)
 
1771
{
 
1772
        struct tevent_req *req =
 
1773
                tevent_req_callback_data(subreq,
 
1774
                struct tevent_req);
 
1775
        NTSTATUS status;
 
1776
 
 
1777
        status = dcerpc_binding_handle_call_recv(subreq);
 
1778
        if (!NT_STATUS_IS_OK(status)) {
 
1779
                tevent_req_nterror(req, status);
 
1780
                return;
 
1781
        }
 
1782
 
 
1783
        tevent_req_done(req);
 
1784
}
 
1785
 
 
1786
NTSTATUS dcerpc_rap_NetSessionGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1787
{
 
1788
        struct dcerpc_rap_NetSessionGetInfo_r_state *state =
 
1789
                tevent_req_data(req,
 
1790
                struct dcerpc_rap_NetSessionGetInfo_r_state);
 
1791
        NTSTATUS status;
 
1792
 
 
1793
        if (tevent_req_is_nterror(req, &status)) {
 
1794
                tevent_req_received(req);
 
1795
                return status;
 
1796
        }
 
1797
 
 
1798
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1799
 
 
1800
        tevent_req_received(req);
 
1801
        return NT_STATUS_OK;
 
1802
}
 
1803
 
 
1804
NTSTATUS dcerpc_rap_NetSessionGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetSessionGetInfo *r)
 
1805
{
 
1806
        NTSTATUS status;
 
1807
 
 
1808
        status = dcerpc_binding_handle_call(h,
 
1809
                        NULL, &ndr_table_rap,
 
1810
                        NDR_RAP_NETSESSIONGETINFO, mem_ctx, r);
 
1811
 
 
1812
        return status;
 
1813
}
 
1814
 
 
1815
struct dcerpc_rap_NetUserAdd_r_state {
 
1816
        TALLOC_CTX *out_mem_ctx;
 
1817
};
 
1818
 
 
1819
static void dcerpc_rap_NetUserAdd_r_done(struct tevent_req *subreq);
 
1820
 
 
1821
struct tevent_req *dcerpc_rap_NetUserAdd_r_send(TALLOC_CTX *mem_ctx,
 
1822
        struct tevent_context *ev,
 
1823
        struct dcerpc_binding_handle *h,
 
1824
        struct rap_NetUserAdd *r)
 
1825
{
 
1826
        struct tevent_req *req;
 
1827
        struct dcerpc_rap_NetUserAdd_r_state *state;
 
1828
        struct tevent_req *subreq;
 
1829
 
 
1830
        req = tevent_req_create(mem_ctx, &state,
 
1831
                                struct dcerpc_rap_NetUserAdd_r_state);
 
1832
        if (req == NULL) {
 
1833
                return NULL;
 
1834
        }
 
1835
 
 
1836
        state->out_mem_ctx = talloc_new(state);
 
1837
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1838
                return tevent_req_post(req, ev);
 
1839
        }
 
1840
 
 
1841
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1842
                        NULL, &ndr_table_rap,
 
1843
                        NDR_RAP_NETUSERADD, state->out_mem_ctx, r);
 
1844
        if (tevent_req_nomem(subreq, req)) {
 
1845
                return tevent_req_post(req, ev);
 
1846
        }
 
1847
        tevent_req_set_callback(subreq, dcerpc_rap_NetUserAdd_r_done, req);
 
1848
 
 
1849
        return req;
 
1850
}
 
1851
 
 
1852
static void dcerpc_rap_NetUserAdd_r_done(struct tevent_req *subreq)
 
1853
{
 
1854
        struct tevent_req *req =
 
1855
                tevent_req_callback_data(subreq,
 
1856
                struct tevent_req);
 
1857
        NTSTATUS status;
 
1858
 
 
1859
        status = dcerpc_binding_handle_call_recv(subreq);
 
1860
        if (!NT_STATUS_IS_OK(status)) {
 
1861
                tevent_req_nterror(req, status);
 
1862
                return;
 
1863
        }
 
1864
 
 
1865
        tevent_req_done(req);
 
1866
}
 
1867
 
 
1868
NTSTATUS dcerpc_rap_NetUserAdd_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1869
{
 
1870
        struct dcerpc_rap_NetUserAdd_r_state *state =
 
1871
                tevent_req_data(req,
 
1872
                struct dcerpc_rap_NetUserAdd_r_state);
 
1873
        NTSTATUS status;
 
1874
 
 
1875
        if (tevent_req_is_nterror(req, &status)) {
 
1876
                tevent_req_received(req);
 
1877
                return status;
 
1878
        }
 
1879
 
 
1880
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1881
 
 
1882
        tevent_req_received(req);
 
1883
        return NT_STATUS_OK;
 
1884
}
 
1885
 
 
1886
NTSTATUS dcerpc_rap_NetUserAdd_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetUserAdd *r)
 
1887
{
 
1888
        NTSTATUS status;
 
1889
 
 
1890
        status = dcerpc_binding_handle_call(h,
 
1891
                        NULL, &ndr_table_rap,
 
1892
                        NDR_RAP_NETUSERADD, mem_ctx, r);
 
1893
 
 
1894
        return status;
 
1895
}
 
1896
 
 
1897
struct dcerpc_rap_NetUserDelete_r_state {
 
1898
        TALLOC_CTX *out_mem_ctx;
 
1899
};
 
1900
 
 
1901
static void dcerpc_rap_NetUserDelete_r_done(struct tevent_req *subreq);
 
1902
 
 
1903
struct tevent_req *dcerpc_rap_NetUserDelete_r_send(TALLOC_CTX *mem_ctx,
 
1904
        struct tevent_context *ev,
 
1905
        struct dcerpc_binding_handle *h,
 
1906
        struct rap_NetUserDelete *r)
 
1907
{
 
1908
        struct tevent_req *req;
 
1909
        struct dcerpc_rap_NetUserDelete_r_state *state;
 
1910
        struct tevent_req *subreq;
 
1911
 
 
1912
        req = tevent_req_create(mem_ctx, &state,
 
1913
                                struct dcerpc_rap_NetUserDelete_r_state);
 
1914
        if (req == NULL) {
 
1915
                return NULL;
 
1916
        }
 
1917
 
 
1918
        state->out_mem_ctx = talloc_new(state);
 
1919
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
1920
                return tevent_req_post(req, ev);
 
1921
        }
 
1922
 
 
1923
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
1924
                        NULL, &ndr_table_rap,
 
1925
                        NDR_RAP_NETUSERDELETE, state->out_mem_ctx, r);
 
1926
        if (tevent_req_nomem(subreq, req)) {
 
1927
                return tevent_req_post(req, ev);
 
1928
        }
 
1929
        tevent_req_set_callback(subreq, dcerpc_rap_NetUserDelete_r_done, req);
 
1930
 
 
1931
        return req;
 
1932
}
 
1933
 
 
1934
static void dcerpc_rap_NetUserDelete_r_done(struct tevent_req *subreq)
 
1935
{
 
1936
        struct tevent_req *req =
 
1937
                tevent_req_callback_data(subreq,
 
1938
                struct tevent_req);
 
1939
        NTSTATUS status;
 
1940
 
 
1941
        status = dcerpc_binding_handle_call_recv(subreq);
 
1942
        if (!NT_STATUS_IS_OK(status)) {
 
1943
                tevent_req_nterror(req, status);
 
1944
                return;
 
1945
        }
 
1946
 
 
1947
        tevent_req_done(req);
 
1948
}
 
1949
 
 
1950
NTSTATUS dcerpc_rap_NetUserDelete_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
1951
{
 
1952
        struct dcerpc_rap_NetUserDelete_r_state *state =
 
1953
                tevent_req_data(req,
 
1954
                struct dcerpc_rap_NetUserDelete_r_state);
 
1955
        NTSTATUS status;
 
1956
 
 
1957
        if (tevent_req_is_nterror(req, &status)) {
 
1958
                tevent_req_received(req);
 
1959
                return status;
 
1960
        }
 
1961
 
 
1962
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
1963
 
 
1964
        tevent_req_received(req);
 
1965
        return NT_STATUS_OK;
 
1966
}
 
1967
 
 
1968
NTSTATUS dcerpc_rap_NetUserDelete_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetUserDelete *r)
 
1969
{
 
1970
        NTSTATUS status;
 
1971
 
 
1972
        status = dcerpc_binding_handle_call(h,
 
1973
                        NULL, &ndr_table_rap,
 
1974
                        NDR_RAP_NETUSERDELETE, mem_ctx, r);
 
1975
 
 
1976
        return status;
 
1977
}
 
1978
 
 
1979
struct dcerpc_rap_NetRemoteTOD_r_state {
 
1980
        TALLOC_CTX *out_mem_ctx;
 
1981
};
 
1982
 
 
1983
static void dcerpc_rap_NetRemoteTOD_r_done(struct tevent_req *subreq);
 
1984
 
 
1985
struct tevent_req *dcerpc_rap_NetRemoteTOD_r_send(TALLOC_CTX *mem_ctx,
 
1986
        struct tevent_context *ev,
 
1987
        struct dcerpc_binding_handle *h,
 
1988
        struct rap_NetRemoteTOD *r)
 
1989
{
 
1990
        struct tevent_req *req;
 
1991
        struct dcerpc_rap_NetRemoteTOD_r_state *state;
 
1992
        struct tevent_req *subreq;
 
1993
 
 
1994
        req = tevent_req_create(mem_ctx, &state,
 
1995
                                struct dcerpc_rap_NetRemoteTOD_r_state);
 
1996
        if (req == NULL) {
 
1997
                return NULL;
 
1998
        }
 
1999
 
 
2000
        state->out_mem_ctx = talloc_new(state);
 
2001
        if (tevent_req_nomem(state->out_mem_ctx, req)) {
 
2002
                return tevent_req_post(req, ev);
 
2003
        }
 
2004
 
 
2005
        subreq = dcerpc_binding_handle_call_send(state, ev, h,
 
2006
                        NULL, &ndr_table_rap,
 
2007
                        NDR_RAP_NETREMOTETOD, state->out_mem_ctx, r);
 
2008
        if (tevent_req_nomem(subreq, req)) {
 
2009
                return tevent_req_post(req, ev);
 
2010
        }
 
2011
        tevent_req_set_callback(subreq, dcerpc_rap_NetRemoteTOD_r_done, req);
 
2012
 
 
2013
        return req;
 
2014
}
 
2015
 
 
2016
static void dcerpc_rap_NetRemoteTOD_r_done(struct tevent_req *subreq)
 
2017
{
 
2018
        struct tevent_req *req =
 
2019
                tevent_req_callback_data(subreq,
 
2020
                struct tevent_req);
 
2021
        NTSTATUS status;
 
2022
 
 
2023
        status = dcerpc_binding_handle_call_recv(subreq);
 
2024
        if (!NT_STATUS_IS_OK(status)) {
 
2025
                tevent_req_nterror(req, status);
 
2026
                return;
 
2027
        }
 
2028
 
 
2029
        tevent_req_done(req);
 
2030
}
 
2031
 
 
2032
NTSTATUS dcerpc_rap_NetRemoteTOD_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 
2033
{
 
2034
        struct dcerpc_rap_NetRemoteTOD_r_state *state =
 
2035
                tevent_req_data(req,
 
2036
                struct dcerpc_rap_NetRemoteTOD_r_state);
 
2037
        NTSTATUS status;
 
2038
 
 
2039
        if (tevent_req_is_nterror(req, &status)) {
 
2040
                tevent_req_received(req);
 
2041
                return status;
 
2042
        }
 
2043
 
 
2044
        talloc_steal(mem_ctx, state->out_mem_ctx);
 
2045
 
 
2046
        tevent_req_received(req);
 
2047
        return NT_STATUS_OK;
 
2048
}
 
2049
 
 
2050
NTSTATUS dcerpc_rap_NetRemoteTOD_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetRemoteTOD *r)
 
2051
{
 
2052
        NTSTATUS status;
 
2053
 
 
2054
        status = dcerpc_binding_handle_call(h,
 
2055
                        NULL, &ndr_table_rap,
 
2056
                        NDR_RAP_NETREMOTETOD, mem_ctx, r);
 
2057
 
 
2058
        return status;
 
2059
}
 
2060