← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/srv_lsa.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

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