← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

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