← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/srv_netlogon.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_netlogon.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_netlogon.h"
 
8
 
 
9
static bool api_netr_LogonUasLogon(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 netr_LogonUasLogon *r;
 
17
 
 
18
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONUASLOGON];
 
19
 
 
20
        r = talloc(talloc_tos(), struct netr_LogonUasLogon);
 
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(netr_LogonUasLogon, r);
 
45
        }
 
46
 
 
47
        ZERO_STRUCT(r->out);
 
48
        r->out.info = talloc_zero(r, struct netr_UasInfo *);
 
49
        if (r->out.info == NULL) {
 
50
                talloc_free(r);
 
51
                return false;
 
52
        }
 
53
 
 
54
        r->out.result = _netr_LogonUasLogon(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(netr_LogonUasLogon, 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_netr_LogonUasLogoff(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 netr_LogonUasLogoff *r;
 
97
 
 
98
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONUASLOGOFF];
 
99
 
 
100
        r = talloc(talloc_tos(), struct netr_LogonUasLogoff);
 
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(netr_LogonUasLogoff, r);
 
125
        }
 
126
 
 
127
        ZERO_STRUCT(r->out);
 
128
        r->out.info = talloc_zero(r, struct netr_UasLogoffInfo);
 
129
        if (r->out.info == NULL) {
 
130
                talloc_free(r);
 
131
                return false;
 
132
        }
 
133
 
 
134
        r->out.result = _netr_LogonUasLogoff(p, r);
 
135
 
 
136
        if (p->rng_fault_state) {
 
137
                talloc_free(r);
 
138
                /* Return true here, srv_pipe_hnd.c will take care */
 
139
                return true;
 
140
        }
 
141
 
 
142
        if (DEBUGLEVEL >= 10) {
 
143
                NDR_PRINT_OUT_DEBUG(netr_LogonUasLogoff, r);
 
144
        }
 
145
 
 
146
        push = ndr_push_init_ctx(r, NULL);
 
147
        if (push == NULL) {
 
148
                talloc_free(r);
 
149
                return false;
 
150
        }
 
151
 
 
152
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
153
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
154
                talloc_free(r);
 
155
                return false;
 
156
        }
 
157
 
 
158
        blob = ndr_push_blob(push);
 
159
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
160
                talloc_free(r);
 
161
                return false;
 
162
        }
 
163
 
 
164
        talloc_free(r);
 
165
 
 
166
        return true;
 
167
}
 
168
 
 
169
static bool api_netr_LogonSamLogon(pipes_struct *p)
 
170
{
 
171
        const struct ndr_interface_call *call;
 
172
        struct ndr_pull *pull;
 
173
        struct ndr_push *push;
 
174
        enum ndr_err_code ndr_err;
 
175
        DATA_BLOB blob;
 
176
        struct netr_LogonSamLogon *r;
 
177
 
 
178
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONSAMLOGON];
 
179
 
 
180
        r = talloc(talloc_tos(), struct netr_LogonSamLogon);
 
181
        if (r == NULL) {
 
182
                return false;
 
183
        }
 
184
 
 
185
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
186
                talloc_free(r);
 
187
                return false;
 
188
        }
 
189
 
 
190
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
191
        if (pull == NULL) {
 
192
                talloc_free(r);
 
193
                return false;
 
194
        }
 
195
 
 
196
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
197
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
198
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
199
                talloc_free(r);
 
200
                return false;
 
201
        }
 
202
 
 
203
        if (DEBUGLEVEL >= 10) {
 
204
                NDR_PRINT_IN_DEBUG(netr_LogonSamLogon, r);
 
205
        }
 
206
 
 
207
        ZERO_STRUCT(r->out);
 
208
        r->out.return_authenticator = r->in.return_authenticator;
 
209
        r->out.validation = talloc_zero(r, union netr_Validation);
 
210
        if (r->out.validation == NULL) {
 
211
                talloc_free(r);
 
212
                return false;
 
213
        }
 
214
 
 
215
        r->out.authoritative = talloc_zero(r, uint8_t);
 
216
        if (r->out.authoritative == NULL) {
 
217
                talloc_free(r);
 
218
                return false;
 
219
        }
 
220
 
 
221
        r->out.result = _netr_LogonSamLogon(p, r);
 
222
 
 
223
        if (p->rng_fault_state) {
 
224
                talloc_free(r);
 
225
                /* Return true here, srv_pipe_hnd.c will take care */
 
226
                return true;
 
227
        }
 
228
 
 
229
        if (DEBUGLEVEL >= 10) {
 
230
                NDR_PRINT_OUT_DEBUG(netr_LogonSamLogon, r);
 
231
        }
 
232
 
 
233
        push = ndr_push_init_ctx(r, NULL);
 
234
        if (push == NULL) {
 
235
                talloc_free(r);
 
236
                return false;
 
237
        }
 
238
 
 
239
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
240
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
241
                talloc_free(r);
 
242
                return false;
 
243
        }
 
244
 
 
245
        blob = ndr_push_blob(push);
 
246
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
247
                talloc_free(r);
 
248
                return false;
 
249
        }
 
250
 
 
251
        talloc_free(r);
 
252
 
 
253
        return true;
 
254
}
 
255
 
 
256
static bool api_netr_LogonSamLogoff(pipes_struct *p)
 
257
{
 
258
        const struct ndr_interface_call *call;
 
259
        struct ndr_pull *pull;
 
260
        struct ndr_push *push;
 
261
        enum ndr_err_code ndr_err;
 
262
        DATA_BLOB blob;
 
263
        struct netr_LogonSamLogoff *r;
 
264
 
 
265
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONSAMLOGOFF];
 
266
 
 
267
        r = talloc(talloc_tos(), struct netr_LogonSamLogoff);
 
268
        if (r == NULL) {
 
269
                return false;
 
270
        }
 
271
 
 
272
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
273
                talloc_free(r);
 
274
                return false;
 
275
        }
 
276
 
 
277
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
278
        if (pull == NULL) {
 
279
                talloc_free(r);
 
280
                return false;
 
281
        }
 
282
 
 
283
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
284
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
285
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
286
                talloc_free(r);
 
287
                return false;
 
288
        }
 
289
 
 
290
        if (DEBUGLEVEL >= 10) {
 
291
                NDR_PRINT_IN_DEBUG(netr_LogonSamLogoff, r);
 
292
        }
 
293
 
 
294
        ZERO_STRUCT(r->out);
 
295
        r->out.return_authenticator = r->in.return_authenticator;
 
296
        r->out.result = _netr_LogonSamLogoff(p, r);
 
297
 
 
298
        if (p->rng_fault_state) {
 
299
                talloc_free(r);
 
300
                /* Return true here, srv_pipe_hnd.c will take care */
 
301
                return true;
 
302
        }
 
303
 
 
304
        if (DEBUGLEVEL >= 10) {
 
305
                NDR_PRINT_OUT_DEBUG(netr_LogonSamLogoff, r);
 
306
        }
 
307
 
 
308
        push = ndr_push_init_ctx(r, NULL);
 
309
        if (push == NULL) {
 
310
                talloc_free(r);
 
311
                return false;
 
312
        }
 
313
 
 
314
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
315
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
316
                talloc_free(r);
 
317
                return false;
 
318
        }
 
319
 
 
320
        blob = ndr_push_blob(push);
 
321
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
322
                talloc_free(r);
 
323
                return false;
 
324
        }
 
325
 
 
326
        talloc_free(r);
 
327
 
 
328
        return true;
 
329
}
 
330
 
 
331
static bool api_netr_ServerReqChallenge(pipes_struct *p)
 
332
{
 
333
        const struct ndr_interface_call *call;
 
334
        struct ndr_pull *pull;
 
335
        struct ndr_push *push;
 
336
        enum ndr_err_code ndr_err;
 
337
        DATA_BLOB blob;
 
338
        struct netr_ServerReqChallenge *r;
 
339
 
 
340
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERREQCHALLENGE];
 
341
 
 
342
        r = talloc(talloc_tos(), struct netr_ServerReqChallenge);
 
343
        if (r == NULL) {
 
344
                return false;
 
345
        }
 
346
 
 
347
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
348
                talloc_free(r);
 
349
                return false;
 
350
        }
 
351
 
 
352
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
353
        if (pull == NULL) {
 
354
                talloc_free(r);
 
355
                return false;
 
356
        }
 
357
 
 
358
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
359
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
360
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
361
                talloc_free(r);
 
362
                return false;
 
363
        }
 
364
 
 
365
        if (DEBUGLEVEL >= 10) {
 
366
                NDR_PRINT_IN_DEBUG(netr_ServerReqChallenge, r);
 
367
        }
 
368
 
 
369
        ZERO_STRUCT(r->out);
 
370
        r->out.return_credentials = talloc_zero(r, struct netr_Credential);
 
371
        if (r->out.return_credentials == NULL) {
 
372
                talloc_free(r);
 
373
                return false;
 
374
        }
 
375
 
 
376
        r->out.result = _netr_ServerReqChallenge(p, r);
 
377
 
 
378
        if (p->rng_fault_state) {
 
379
                talloc_free(r);
 
380
                /* Return true here, srv_pipe_hnd.c will take care */
 
381
                return true;
 
382
        }
 
383
 
 
384
        if (DEBUGLEVEL >= 10) {
 
385
                NDR_PRINT_OUT_DEBUG(netr_ServerReqChallenge, r);
 
386
        }
 
387
 
 
388
        push = ndr_push_init_ctx(r, NULL);
 
389
        if (push == NULL) {
 
390
                talloc_free(r);
 
391
                return false;
 
392
        }
 
393
 
 
394
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
395
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
396
                talloc_free(r);
 
397
                return false;
 
398
        }
 
399
 
 
400
        blob = ndr_push_blob(push);
 
401
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
402
                talloc_free(r);
 
403
                return false;
 
404
        }
 
405
 
 
406
        talloc_free(r);
 
407
 
 
408
        return true;
 
409
}
 
410
 
 
411
static bool api_netr_ServerAuthenticate(pipes_struct *p)
 
412
{
 
413
        const struct ndr_interface_call *call;
 
414
        struct ndr_pull *pull;
 
415
        struct ndr_push *push;
 
416
        enum ndr_err_code ndr_err;
 
417
        DATA_BLOB blob;
 
418
        struct netr_ServerAuthenticate *r;
 
419
 
 
420
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERAUTHENTICATE];
 
421
 
 
422
        r = talloc(talloc_tos(), struct netr_ServerAuthenticate);
 
423
        if (r == NULL) {
 
424
                return false;
 
425
        }
 
426
 
 
427
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
428
                talloc_free(r);
 
429
                return false;
 
430
        }
 
431
 
 
432
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
433
        if (pull == NULL) {
 
434
                talloc_free(r);
 
435
                return false;
 
436
        }
 
437
 
 
438
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
439
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
440
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
441
                talloc_free(r);
 
442
                return false;
 
443
        }
 
444
 
 
445
        if (DEBUGLEVEL >= 10) {
 
446
                NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate, r);
 
447
        }
 
448
 
 
449
        ZERO_STRUCT(r->out);
 
450
        r->out.return_credentials = talloc_zero(r, struct netr_Credential);
 
451
        if (r->out.return_credentials == NULL) {
 
452
                talloc_free(r);
 
453
                return false;
 
454
        }
 
455
 
 
456
        r->out.result = _netr_ServerAuthenticate(p, r);
 
457
 
 
458
        if (p->rng_fault_state) {
 
459
                talloc_free(r);
 
460
                /* Return true here, srv_pipe_hnd.c will take care */
 
461
                return true;
 
462
        }
 
463
 
 
464
        if (DEBUGLEVEL >= 10) {
 
465
                NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate, r);
 
466
        }
 
467
 
 
468
        push = ndr_push_init_ctx(r, NULL);
 
469
        if (push == NULL) {
 
470
                talloc_free(r);
 
471
                return false;
 
472
        }
 
473
 
 
474
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
475
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
476
                talloc_free(r);
 
477
                return false;
 
478
        }
 
479
 
 
480
        blob = ndr_push_blob(push);
 
481
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
482
                talloc_free(r);
 
483
                return false;
 
484
        }
 
485
 
 
486
        talloc_free(r);
 
487
 
 
488
        return true;
 
489
}
 
490
 
 
491
static bool api_netr_ServerPasswordSet(pipes_struct *p)
 
492
{
 
493
        const struct ndr_interface_call *call;
 
494
        struct ndr_pull *pull;
 
495
        struct ndr_push *push;
 
496
        enum ndr_err_code ndr_err;
 
497
        DATA_BLOB blob;
 
498
        struct netr_ServerPasswordSet *r;
 
499
 
 
500
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERPASSWORDSET];
 
501
 
 
502
        r = talloc(talloc_tos(), struct netr_ServerPasswordSet);
 
503
        if (r == NULL) {
 
504
                return false;
 
505
        }
 
506
 
 
507
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
508
                talloc_free(r);
 
509
                return false;
 
510
        }
 
511
 
 
512
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
513
        if (pull == NULL) {
 
514
                talloc_free(r);
 
515
                return false;
 
516
        }
 
517
 
 
518
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
519
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
520
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
521
                talloc_free(r);
 
522
                return false;
 
523
        }
 
524
 
 
525
        if (DEBUGLEVEL >= 10) {
 
526
                NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet, r);
 
527
        }
 
528
 
 
529
        ZERO_STRUCT(r->out);
 
530
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
531
        if (r->out.return_authenticator == NULL) {
 
532
                talloc_free(r);
 
533
                return false;
 
534
        }
 
535
 
 
536
        r->out.result = _netr_ServerPasswordSet(p, r);
 
537
 
 
538
        if (p->rng_fault_state) {
 
539
                talloc_free(r);
 
540
                /* Return true here, srv_pipe_hnd.c will take care */
 
541
                return true;
 
542
        }
 
543
 
 
544
        if (DEBUGLEVEL >= 10) {
 
545
                NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet, r);
 
546
        }
 
547
 
 
548
        push = ndr_push_init_ctx(r, NULL);
 
549
        if (push == NULL) {
 
550
                talloc_free(r);
 
551
                return false;
 
552
        }
 
553
 
 
554
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
555
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
556
                talloc_free(r);
 
557
                return false;
 
558
        }
 
559
 
 
560
        blob = ndr_push_blob(push);
 
561
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
562
                talloc_free(r);
 
563
                return false;
 
564
        }
 
565
 
 
566
        talloc_free(r);
 
567
 
 
568
        return true;
 
569
}
 
570
 
 
571
static bool api_netr_DatabaseDeltas(pipes_struct *p)
 
572
{
 
573
        const struct ndr_interface_call *call;
 
574
        struct ndr_pull *pull;
 
575
        struct ndr_push *push;
 
576
        enum ndr_err_code ndr_err;
 
577
        DATA_BLOB blob;
 
578
        struct netr_DatabaseDeltas *r;
 
579
 
 
580
        call = &ndr_table_netlogon.calls[NDR_NETR_DATABASEDELTAS];
 
581
 
 
582
        r = talloc(talloc_tos(), struct netr_DatabaseDeltas);
 
583
        if (r == NULL) {
 
584
                return false;
 
585
        }
 
586
 
 
587
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
588
                talloc_free(r);
 
589
                return false;
 
590
        }
 
591
 
 
592
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
593
        if (pull == NULL) {
 
594
                talloc_free(r);
 
595
                return false;
 
596
        }
 
597
 
 
598
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
599
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
600
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
601
                talloc_free(r);
 
602
                return false;
 
603
        }
 
604
 
 
605
        if (DEBUGLEVEL >= 10) {
 
606
                NDR_PRINT_IN_DEBUG(netr_DatabaseDeltas, r);
 
607
        }
 
608
 
 
609
        ZERO_STRUCT(r->out);
 
610
        r->out.return_authenticator = r->in.return_authenticator;
 
611
        r->out.sequence_num = r->in.sequence_num;
 
612
        r->out.delta_enum_array = talloc_zero(r, struct netr_DELTA_ENUM_ARRAY *);
 
613
        if (r->out.delta_enum_array == NULL) {
 
614
                talloc_free(r);
 
615
                return false;
 
616
        }
 
617
 
 
618
        r->out.result = _netr_DatabaseDeltas(p, r);
 
619
 
 
620
        if (p->rng_fault_state) {
 
621
                talloc_free(r);
 
622
                /* Return true here, srv_pipe_hnd.c will take care */
 
623
                return true;
 
624
        }
 
625
 
 
626
        if (DEBUGLEVEL >= 10) {
 
627
                NDR_PRINT_OUT_DEBUG(netr_DatabaseDeltas, r);
 
628
        }
 
629
 
 
630
        push = ndr_push_init_ctx(r, NULL);
 
631
        if (push == NULL) {
 
632
                talloc_free(r);
 
633
                return false;
 
634
        }
 
635
 
 
636
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
637
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
638
                talloc_free(r);
 
639
                return false;
 
640
        }
 
641
 
 
642
        blob = ndr_push_blob(push);
 
643
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
644
                talloc_free(r);
 
645
                return false;
 
646
        }
 
647
 
 
648
        talloc_free(r);
 
649
 
 
650
        return true;
 
651
}
 
652
 
 
653
static bool api_netr_DatabaseSync(pipes_struct *p)
 
654
{
 
655
        const struct ndr_interface_call *call;
 
656
        struct ndr_pull *pull;
 
657
        struct ndr_push *push;
 
658
        enum ndr_err_code ndr_err;
 
659
        DATA_BLOB blob;
 
660
        struct netr_DatabaseSync *r;
 
661
 
 
662
        call = &ndr_table_netlogon.calls[NDR_NETR_DATABASESYNC];
 
663
 
 
664
        r = talloc(talloc_tos(), struct netr_DatabaseSync);
 
665
        if (r == NULL) {
 
666
                return false;
 
667
        }
 
668
 
 
669
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
670
                talloc_free(r);
 
671
                return false;
 
672
        }
 
673
 
 
674
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
675
        if (pull == NULL) {
 
676
                talloc_free(r);
 
677
                return false;
 
678
        }
 
679
 
 
680
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
681
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
682
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
683
                talloc_free(r);
 
684
                return false;
 
685
        }
 
686
 
 
687
        if (DEBUGLEVEL >= 10) {
 
688
                NDR_PRINT_IN_DEBUG(netr_DatabaseSync, r);
 
689
        }
 
690
 
 
691
        ZERO_STRUCT(r->out);
 
692
        r->out.return_authenticator = r->in.return_authenticator;
 
693
        r->out.sync_context = r->in.sync_context;
 
694
        r->out.delta_enum_array = talloc_zero(r, struct netr_DELTA_ENUM_ARRAY *);
 
695
        if (r->out.delta_enum_array == NULL) {
 
696
                talloc_free(r);
 
697
                return false;
 
698
        }
 
699
 
 
700
        r->out.result = _netr_DatabaseSync(p, r);
 
701
 
 
702
        if (p->rng_fault_state) {
 
703
                talloc_free(r);
 
704
                /* Return true here, srv_pipe_hnd.c will take care */
 
705
                return true;
 
706
        }
 
707
 
 
708
        if (DEBUGLEVEL >= 10) {
 
709
                NDR_PRINT_OUT_DEBUG(netr_DatabaseSync, r);
 
710
        }
 
711
 
 
712
        push = ndr_push_init_ctx(r, NULL);
 
713
        if (push == NULL) {
 
714
                talloc_free(r);
 
715
                return false;
 
716
        }
 
717
 
 
718
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
719
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
720
                talloc_free(r);
 
721
                return false;
 
722
        }
 
723
 
 
724
        blob = ndr_push_blob(push);
 
725
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
726
                talloc_free(r);
 
727
                return false;
 
728
        }
 
729
 
 
730
        talloc_free(r);
 
731
 
 
732
        return true;
 
733
}
 
734
 
 
735
static bool api_netr_AccountDeltas(pipes_struct *p)
 
736
{
 
737
        const struct ndr_interface_call *call;
 
738
        struct ndr_pull *pull;
 
739
        struct ndr_push *push;
 
740
        enum ndr_err_code ndr_err;
 
741
        DATA_BLOB blob;
 
742
        struct netr_AccountDeltas *r;
 
743
 
 
744
        call = &ndr_table_netlogon.calls[NDR_NETR_ACCOUNTDELTAS];
 
745
 
 
746
        r = talloc(talloc_tos(), struct netr_AccountDeltas);
 
747
        if (r == NULL) {
 
748
                return false;
 
749
        }
 
750
 
 
751
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
752
                talloc_free(r);
 
753
                return false;
 
754
        }
 
755
 
 
756
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
757
        if (pull == NULL) {
 
758
                talloc_free(r);
 
759
                return false;
 
760
        }
 
761
 
 
762
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
763
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
764
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
765
                talloc_free(r);
 
766
                return false;
 
767
        }
 
768
 
 
769
        if (DEBUGLEVEL >= 10) {
 
770
                NDR_PRINT_IN_DEBUG(netr_AccountDeltas, r);
 
771
        }
 
772
 
 
773
        ZERO_STRUCT(r->out);
 
774
        r->out.return_authenticator = r->in.return_authenticator;
 
775
        r->out.buffer = talloc_zero(r, struct netr_AccountBuffer);
 
776
        if (r->out.buffer == NULL) {
 
777
                talloc_free(r);
 
778
                return false;
 
779
        }
 
780
 
 
781
        r->out.count_returned = talloc_zero(r, uint32_t);
 
782
        if (r->out.count_returned == NULL) {
 
783
                talloc_free(r);
 
784
                return false;
 
785
        }
 
786
 
 
787
        r->out.total_entries = talloc_zero(r, uint32_t);
 
788
        if (r->out.total_entries == NULL) {
 
789
                talloc_free(r);
 
790
                return false;
 
791
        }
 
792
 
 
793
        r->out.recordid = talloc_zero(r, struct netr_UAS_INFO_0);
 
794
        if (r->out.recordid == NULL) {
 
795
                talloc_free(r);
 
796
                return false;
 
797
        }
 
798
 
 
799
        r->out.result = _netr_AccountDeltas(p, r);
 
800
 
 
801
        if (p->rng_fault_state) {
 
802
                talloc_free(r);
 
803
                /* Return true here, srv_pipe_hnd.c will take care */
 
804
                return true;
 
805
        }
 
806
 
 
807
        if (DEBUGLEVEL >= 10) {
 
808
                NDR_PRINT_OUT_DEBUG(netr_AccountDeltas, r);
 
809
        }
 
810
 
 
811
        push = ndr_push_init_ctx(r, NULL);
 
812
        if (push == NULL) {
 
813
                talloc_free(r);
 
814
                return false;
 
815
        }
 
816
 
 
817
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
818
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
819
                talloc_free(r);
 
820
                return false;
 
821
        }
 
822
 
 
823
        blob = ndr_push_blob(push);
 
824
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
825
                talloc_free(r);
 
826
                return false;
 
827
        }
 
828
 
 
829
        talloc_free(r);
 
830
 
 
831
        return true;
 
832
}
 
833
 
 
834
static bool api_netr_AccountSync(pipes_struct *p)
 
835
{
 
836
        const struct ndr_interface_call *call;
 
837
        struct ndr_pull *pull;
 
838
        struct ndr_push *push;
 
839
        enum ndr_err_code ndr_err;
 
840
        DATA_BLOB blob;
 
841
        struct netr_AccountSync *r;
 
842
 
 
843
        call = &ndr_table_netlogon.calls[NDR_NETR_ACCOUNTSYNC];
 
844
 
 
845
        r = talloc(talloc_tos(), struct netr_AccountSync);
 
846
        if (r == NULL) {
 
847
                return false;
 
848
        }
 
849
 
 
850
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
851
                talloc_free(r);
 
852
                return false;
 
853
        }
 
854
 
 
855
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
856
        if (pull == NULL) {
 
857
                talloc_free(r);
 
858
                return false;
 
859
        }
 
860
 
 
861
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
862
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
863
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
864
                talloc_free(r);
 
865
                return false;
 
866
        }
 
867
 
 
868
        if (DEBUGLEVEL >= 10) {
 
869
                NDR_PRINT_IN_DEBUG(netr_AccountSync, r);
 
870
        }
 
871
 
 
872
        ZERO_STRUCT(r->out);
 
873
        r->out.return_authenticator = r->in.return_authenticator;
 
874
        r->out.recordid = r->in.recordid;
 
875
        r->out.buffer = talloc_zero(r, struct netr_AccountBuffer);
 
876
        if (r->out.buffer == NULL) {
 
877
                talloc_free(r);
 
878
                return false;
 
879
        }
 
880
 
 
881
        r->out.count_returned = talloc_zero(r, uint32_t);
 
882
        if (r->out.count_returned == NULL) {
 
883
                talloc_free(r);
 
884
                return false;
 
885
        }
 
886
 
 
887
        r->out.total_entries = talloc_zero(r, uint32_t);
 
888
        if (r->out.total_entries == NULL) {
 
889
                talloc_free(r);
 
890
                return false;
 
891
        }
 
892
 
 
893
        r->out.next_reference = talloc_zero(r, uint32_t);
 
894
        if (r->out.next_reference == NULL) {
 
895
                talloc_free(r);
 
896
                return false;
 
897
        }
 
898
 
 
899
        r->out.result = _netr_AccountSync(p, r);
 
900
 
 
901
        if (p->rng_fault_state) {
 
902
                talloc_free(r);
 
903
                /* Return true here, srv_pipe_hnd.c will take care */
 
904
                return true;
 
905
        }
 
906
 
 
907
        if (DEBUGLEVEL >= 10) {
 
908
                NDR_PRINT_OUT_DEBUG(netr_AccountSync, r);
 
909
        }
 
910
 
 
911
        push = ndr_push_init_ctx(r, NULL);
 
912
        if (push == NULL) {
 
913
                talloc_free(r);
 
914
                return false;
 
915
        }
 
916
 
 
917
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
918
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
919
                talloc_free(r);
 
920
                return false;
 
921
        }
 
922
 
 
923
        blob = ndr_push_blob(push);
 
924
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
925
                talloc_free(r);
 
926
                return false;
 
927
        }
 
928
 
 
929
        talloc_free(r);
 
930
 
 
931
        return true;
 
932
}
 
933
 
 
934
static bool api_netr_GetDcName(pipes_struct *p)
 
935
{
 
936
        const struct ndr_interface_call *call;
 
937
        struct ndr_pull *pull;
 
938
        struct ndr_push *push;
 
939
        enum ndr_err_code ndr_err;
 
940
        DATA_BLOB blob;
 
941
        struct netr_GetDcName *r;
 
942
 
 
943
        call = &ndr_table_netlogon.calls[NDR_NETR_GETDCNAME];
 
944
 
 
945
        r = talloc(talloc_tos(), struct netr_GetDcName);
 
946
        if (r == NULL) {
 
947
                return false;
 
948
        }
 
949
 
 
950
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
951
                talloc_free(r);
 
952
                return false;
 
953
        }
 
954
 
 
955
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
956
        if (pull == NULL) {
 
957
                talloc_free(r);
 
958
                return false;
 
959
        }
 
960
 
 
961
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
962
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
963
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
964
                talloc_free(r);
 
965
                return false;
 
966
        }
 
967
 
 
968
        if (DEBUGLEVEL >= 10) {
 
969
                NDR_PRINT_IN_DEBUG(netr_GetDcName, r);
 
970
        }
 
971
 
 
972
        ZERO_STRUCT(r->out);
 
973
        r->out.dcname = talloc_zero(r, const char *);
 
974
        if (r->out.dcname == NULL) {
 
975
                talloc_free(r);
 
976
                return false;
 
977
        }
 
978
 
 
979
        r->out.result = _netr_GetDcName(p, r);
 
980
 
 
981
        if (p->rng_fault_state) {
 
982
                talloc_free(r);
 
983
                /* Return true here, srv_pipe_hnd.c will take care */
 
984
                return true;
 
985
        }
 
986
 
 
987
        if (DEBUGLEVEL >= 10) {
 
988
                NDR_PRINT_OUT_DEBUG(netr_GetDcName, r);
 
989
        }
 
990
 
 
991
        push = ndr_push_init_ctx(r, NULL);
 
992
        if (push == NULL) {
 
993
                talloc_free(r);
 
994
                return false;
 
995
        }
 
996
 
 
997
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
998
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
999
                talloc_free(r);
 
1000
                return false;
 
1001
        }
 
1002
 
 
1003
        blob = ndr_push_blob(push);
 
1004
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1005
                talloc_free(r);
 
1006
                return false;
 
1007
        }
 
1008
 
 
1009
        talloc_free(r);
 
1010
 
 
1011
        return true;
 
1012
}
 
1013
 
 
1014
static bool api_netr_LogonControl(pipes_struct *p)
 
1015
{
 
1016
        const struct ndr_interface_call *call;
 
1017
        struct ndr_pull *pull;
 
1018
        struct ndr_push *push;
 
1019
        enum ndr_err_code ndr_err;
 
1020
        DATA_BLOB blob;
 
1021
        struct netr_LogonControl *r;
 
1022
 
 
1023
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONCONTROL];
 
1024
 
 
1025
        r = talloc(talloc_tos(), struct netr_LogonControl);
 
1026
        if (r == NULL) {
 
1027
                return false;
 
1028
        }
 
1029
 
 
1030
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1031
                talloc_free(r);
 
1032
                return false;
 
1033
        }
 
1034
 
 
1035
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1036
        if (pull == NULL) {
 
1037
                talloc_free(r);
 
1038
                return false;
 
1039
        }
 
1040
 
 
1041
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1042
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1043
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1044
                talloc_free(r);
 
1045
                return false;
 
1046
        }
 
1047
 
 
1048
        if (DEBUGLEVEL >= 10) {
 
1049
                NDR_PRINT_IN_DEBUG(netr_LogonControl, r);
 
1050
        }
 
1051
 
 
1052
        ZERO_STRUCT(r->out);
 
1053
        r->out.info = talloc_zero(r, union netr_CONTROL_QUERY_INFORMATION);
 
1054
        if (r->out.info == NULL) {
 
1055
                talloc_free(r);
 
1056
                return false;
 
1057
        }
 
1058
 
 
1059
        r->out.result = _netr_LogonControl(p, r);
 
1060
 
 
1061
        if (p->rng_fault_state) {
 
1062
                talloc_free(r);
 
1063
                /* Return true here, srv_pipe_hnd.c will take care */
 
1064
                return true;
 
1065
        }
 
1066
 
 
1067
        if (DEBUGLEVEL >= 10) {
 
1068
                NDR_PRINT_OUT_DEBUG(netr_LogonControl, r);
 
1069
        }
 
1070
 
 
1071
        push = ndr_push_init_ctx(r, NULL);
 
1072
        if (push == NULL) {
 
1073
                talloc_free(r);
 
1074
                return false;
 
1075
        }
 
1076
 
 
1077
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1078
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1079
                talloc_free(r);
 
1080
                return false;
 
1081
        }
 
1082
 
 
1083
        blob = ndr_push_blob(push);
 
1084
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1085
                talloc_free(r);
 
1086
                return false;
 
1087
        }
 
1088
 
 
1089
        talloc_free(r);
 
1090
 
 
1091
        return true;
 
1092
}
 
1093
 
 
1094
static bool api_netr_GetAnyDCName(pipes_struct *p)
 
1095
{
 
1096
        const struct ndr_interface_call *call;
 
1097
        struct ndr_pull *pull;
 
1098
        struct ndr_push *push;
 
1099
        enum ndr_err_code ndr_err;
 
1100
        DATA_BLOB blob;
 
1101
        struct netr_GetAnyDCName *r;
 
1102
 
 
1103
        call = &ndr_table_netlogon.calls[NDR_NETR_GETANYDCNAME];
 
1104
 
 
1105
        r = talloc(talloc_tos(), struct netr_GetAnyDCName);
 
1106
        if (r == NULL) {
 
1107
                return false;
 
1108
        }
 
1109
 
 
1110
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1111
                talloc_free(r);
 
1112
                return false;
 
1113
        }
 
1114
 
 
1115
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1116
        if (pull == NULL) {
 
1117
                talloc_free(r);
 
1118
                return false;
 
1119
        }
 
1120
 
 
1121
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1122
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1123
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1124
                talloc_free(r);
 
1125
                return false;
 
1126
        }
 
1127
 
 
1128
        if (DEBUGLEVEL >= 10) {
 
1129
                NDR_PRINT_IN_DEBUG(netr_GetAnyDCName, r);
 
1130
        }
 
1131
 
 
1132
        ZERO_STRUCT(r->out);
 
1133
        r->out.dcname = talloc_zero(r, const char *);
 
1134
        if (r->out.dcname == NULL) {
 
1135
                talloc_free(r);
 
1136
                return false;
 
1137
        }
 
1138
 
 
1139
        r->out.result = _netr_GetAnyDCName(p, r);
 
1140
 
 
1141
        if (p->rng_fault_state) {
 
1142
                talloc_free(r);
 
1143
                /* Return true here, srv_pipe_hnd.c will take care */
 
1144
                return true;
 
1145
        }
 
1146
 
 
1147
        if (DEBUGLEVEL >= 10) {
 
1148
                NDR_PRINT_OUT_DEBUG(netr_GetAnyDCName, r);
 
1149
        }
 
1150
 
 
1151
        push = ndr_push_init_ctx(r, NULL);
 
1152
        if (push == NULL) {
 
1153
                talloc_free(r);
 
1154
                return false;
 
1155
        }
 
1156
 
 
1157
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1158
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1159
                talloc_free(r);
 
1160
                return false;
 
1161
        }
 
1162
 
 
1163
        blob = ndr_push_blob(push);
 
1164
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1165
                talloc_free(r);
 
1166
                return false;
 
1167
        }
 
1168
 
 
1169
        talloc_free(r);
 
1170
 
 
1171
        return true;
 
1172
}
 
1173
 
 
1174
static bool api_netr_LogonControl2(pipes_struct *p)
 
1175
{
 
1176
        const struct ndr_interface_call *call;
 
1177
        struct ndr_pull *pull;
 
1178
        struct ndr_push *push;
 
1179
        enum ndr_err_code ndr_err;
 
1180
        DATA_BLOB blob;
 
1181
        struct netr_LogonControl2 *r;
 
1182
 
 
1183
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONCONTROL2];
 
1184
 
 
1185
        r = talloc(talloc_tos(), struct netr_LogonControl2);
 
1186
        if (r == NULL) {
 
1187
                return false;
 
1188
        }
 
1189
 
 
1190
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1191
                talloc_free(r);
 
1192
                return false;
 
1193
        }
 
1194
 
 
1195
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1196
        if (pull == NULL) {
 
1197
                talloc_free(r);
 
1198
                return false;
 
1199
        }
 
1200
 
 
1201
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1202
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1203
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1204
                talloc_free(r);
 
1205
                return false;
 
1206
        }
 
1207
 
 
1208
        if (DEBUGLEVEL >= 10) {
 
1209
                NDR_PRINT_IN_DEBUG(netr_LogonControl2, r);
 
1210
        }
 
1211
 
 
1212
        ZERO_STRUCT(r->out);
 
1213
        r->out.query = talloc_zero(r, union netr_CONTROL_QUERY_INFORMATION);
 
1214
        if (r->out.query == NULL) {
 
1215
                talloc_free(r);
 
1216
                return false;
 
1217
        }
 
1218
 
 
1219
        r->out.result = _netr_LogonControl2(p, r);
 
1220
 
 
1221
        if (p->rng_fault_state) {
 
1222
                talloc_free(r);
 
1223
                /* Return true here, srv_pipe_hnd.c will take care */
 
1224
                return true;
 
1225
        }
 
1226
 
 
1227
        if (DEBUGLEVEL >= 10) {
 
1228
                NDR_PRINT_OUT_DEBUG(netr_LogonControl2, r);
 
1229
        }
 
1230
 
 
1231
        push = ndr_push_init_ctx(r, NULL);
 
1232
        if (push == NULL) {
 
1233
                talloc_free(r);
 
1234
                return false;
 
1235
        }
 
1236
 
 
1237
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1238
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1239
                talloc_free(r);
 
1240
                return false;
 
1241
        }
 
1242
 
 
1243
        blob = ndr_push_blob(push);
 
1244
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1245
                talloc_free(r);
 
1246
                return false;
 
1247
        }
 
1248
 
 
1249
        talloc_free(r);
 
1250
 
 
1251
        return true;
 
1252
}
 
1253
 
 
1254
static bool api_netr_ServerAuthenticate2(pipes_struct *p)
 
1255
{
 
1256
        const struct ndr_interface_call *call;
 
1257
        struct ndr_pull *pull;
 
1258
        struct ndr_push *push;
 
1259
        enum ndr_err_code ndr_err;
 
1260
        DATA_BLOB blob;
 
1261
        struct netr_ServerAuthenticate2 *r;
 
1262
 
 
1263
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERAUTHENTICATE2];
 
1264
 
 
1265
        r = talloc(talloc_tos(), struct netr_ServerAuthenticate2);
 
1266
        if (r == NULL) {
 
1267
                return false;
 
1268
        }
 
1269
 
 
1270
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1271
                talloc_free(r);
 
1272
                return false;
 
1273
        }
 
1274
 
 
1275
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1276
        if (pull == NULL) {
 
1277
                talloc_free(r);
 
1278
                return false;
 
1279
        }
 
1280
 
 
1281
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1282
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1283
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1284
                talloc_free(r);
 
1285
                return false;
 
1286
        }
 
1287
 
 
1288
        if (DEBUGLEVEL >= 10) {
 
1289
                NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate2, r);
 
1290
        }
 
1291
 
 
1292
        ZERO_STRUCT(r->out);
 
1293
        r->out.negotiate_flags = r->in.negotiate_flags;
 
1294
        r->out.return_credentials = talloc_zero(r, struct netr_Credential);
 
1295
        if (r->out.return_credentials == NULL) {
 
1296
                talloc_free(r);
 
1297
                return false;
 
1298
        }
 
1299
 
 
1300
        r->out.result = _netr_ServerAuthenticate2(p, r);
 
1301
 
 
1302
        if (p->rng_fault_state) {
 
1303
                talloc_free(r);
 
1304
                /* Return true here, srv_pipe_hnd.c will take care */
 
1305
                return true;
 
1306
        }
 
1307
 
 
1308
        if (DEBUGLEVEL >= 10) {
 
1309
                NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate2, r);
 
1310
        }
 
1311
 
 
1312
        push = ndr_push_init_ctx(r, NULL);
 
1313
        if (push == NULL) {
 
1314
                talloc_free(r);
 
1315
                return false;
 
1316
        }
 
1317
 
 
1318
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1319
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1320
                talloc_free(r);
 
1321
                return false;
 
1322
        }
 
1323
 
 
1324
        blob = ndr_push_blob(push);
 
1325
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1326
                talloc_free(r);
 
1327
                return false;
 
1328
        }
 
1329
 
 
1330
        talloc_free(r);
 
1331
 
 
1332
        return true;
 
1333
}
 
1334
 
 
1335
static bool api_netr_DatabaseSync2(pipes_struct *p)
 
1336
{
 
1337
        const struct ndr_interface_call *call;
 
1338
        struct ndr_pull *pull;
 
1339
        struct ndr_push *push;
 
1340
        enum ndr_err_code ndr_err;
 
1341
        DATA_BLOB blob;
 
1342
        struct netr_DatabaseSync2 *r;
 
1343
 
 
1344
        call = &ndr_table_netlogon.calls[NDR_NETR_DATABASESYNC2];
 
1345
 
 
1346
        r = talloc(talloc_tos(), struct netr_DatabaseSync2);
 
1347
        if (r == NULL) {
 
1348
                return false;
 
1349
        }
 
1350
 
 
1351
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1352
                talloc_free(r);
 
1353
                return false;
 
1354
        }
 
1355
 
 
1356
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1357
        if (pull == NULL) {
 
1358
                talloc_free(r);
 
1359
                return false;
 
1360
        }
 
1361
 
 
1362
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1363
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1364
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1365
                talloc_free(r);
 
1366
                return false;
 
1367
        }
 
1368
 
 
1369
        if (DEBUGLEVEL >= 10) {
 
1370
                NDR_PRINT_IN_DEBUG(netr_DatabaseSync2, r);
 
1371
        }
 
1372
 
 
1373
        ZERO_STRUCT(r->out);
 
1374
        r->out.return_authenticator = r->in.return_authenticator;
 
1375
        r->out.sync_context = r->in.sync_context;
 
1376
        r->out.delta_enum_array = talloc_zero(r, struct netr_DELTA_ENUM_ARRAY *);
 
1377
        if (r->out.delta_enum_array == NULL) {
 
1378
                talloc_free(r);
 
1379
                return false;
 
1380
        }
 
1381
 
 
1382
        r->out.result = _netr_DatabaseSync2(p, r);
 
1383
 
 
1384
        if (p->rng_fault_state) {
 
1385
                talloc_free(r);
 
1386
                /* Return true here, srv_pipe_hnd.c will take care */
 
1387
                return true;
 
1388
        }
 
1389
 
 
1390
        if (DEBUGLEVEL >= 10) {
 
1391
                NDR_PRINT_OUT_DEBUG(netr_DatabaseSync2, r);
 
1392
        }
 
1393
 
 
1394
        push = ndr_push_init_ctx(r, NULL);
 
1395
        if (push == NULL) {
 
1396
                talloc_free(r);
 
1397
                return false;
 
1398
        }
 
1399
 
 
1400
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1401
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1402
                talloc_free(r);
 
1403
                return false;
 
1404
        }
 
1405
 
 
1406
        blob = ndr_push_blob(push);
 
1407
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1408
                talloc_free(r);
 
1409
                return false;
 
1410
        }
 
1411
 
 
1412
        talloc_free(r);
 
1413
 
 
1414
        return true;
 
1415
}
 
1416
 
 
1417
static bool api_netr_DatabaseRedo(pipes_struct *p)
 
1418
{
 
1419
        const struct ndr_interface_call *call;
 
1420
        struct ndr_pull *pull;
 
1421
        struct ndr_push *push;
 
1422
        enum ndr_err_code ndr_err;
 
1423
        DATA_BLOB blob;
 
1424
        struct netr_DatabaseRedo *r;
 
1425
 
 
1426
        call = &ndr_table_netlogon.calls[NDR_NETR_DATABASEREDO];
 
1427
 
 
1428
        r = talloc(talloc_tos(), struct netr_DatabaseRedo);
 
1429
        if (r == NULL) {
 
1430
                return false;
 
1431
        }
 
1432
 
 
1433
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1434
                talloc_free(r);
 
1435
                return false;
 
1436
        }
 
1437
 
 
1438
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1439
        if (pull == NULL) {
 
1440
                talloc_free(r);
 
1441
                return false;
 
1442
        }
 
1443
 
 
1444
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1445
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1446
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1447
                talloc_free(r);
 
1448
                return false;
 
1449
        }
 
1450
 
 
1451
        if (DEBUGLEVEL >= 10) {
 
1452
                NDR_PRINT_IN_DEBUG(netr_DatabaseRedo, r);
 
1453
        }
 
1454
 
 
1455
        ZERO_STRUCT(r->out);
 
1456
        r->out.return_authenticator = r->in.return_authenticator;
 
1457
        r->out.delta_enum_array = talloc_zero(r, struct netr_DELTA_ENUM_ARRAY *);
 
1458
        if (r->out.delta_enum_array == NULL) {
 
1459
                talloc_free(r);
 
1460
                return false;
 
1461
        }
 
1462
 
 
1463
        r->out.result = _netr_DatabaseRedo(p, r);
 
1464
 
 
1465
        if (p->rng_fault_state) {
 
1466
                talloc_free(r);
 
1467
                /* Return true here, srv_pipe_hnd.c will take care */
 
1468
                return true;
 
1469
        }
 
1470
 
 
1471
        if (DEBUGLEVEL >= 10) {
 
1472
                NDR_PRINT_OUT_DEBUG(netr_DatabaseRedo, r);
 
1473
        }
 
1474
 
 
1475
        push = ndr_push_init_ctx(r, NULL);
 
1476
        if (push == NULL) {
 
1477
                talloc_free(r);
 
1478
                return false;
 
1479
        }
 
1480
 
 
1481
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1482
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1483
                talloc_free(r);
 
1484
                return false;
 
1485
        }
 
1486
 
 
1487
        blob = ndr_push_blob(push);
 
1488
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1489
                talloc_free(r);
 
1490
                return false;
 
1491
        }
 
1492
 
 
1493
        talloc_free(r);
 
1494
 
 
1495
        return true;
 
1496
}
 
1497
 
 
1498
static bool api_netr_LogonControl2Ex(pipes_struct *p)
 
1499
{
 
1500
        const struct ndr_interface_call *call;
 
1501
        struct ndr_pull *pull;
 
1502
        struct ndr_push *push;
 
1503
        enum ndr_err_code ndr_err;
 
1504
        DATA_BLOB blob;
 
1505
        struct netr_LogonControl2Ex *r;
 
1506
 
 
1507
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONCONTROL2EX];
 
1508
 
 
1509
        r = talloc(talloc_tos(), struct netr_LogonControl2Ex);
 
1510
        if (r == NULL) {
 
1511
                return false;
 
1512
        }
 
1513
 
 
1514
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1515
                talloc_free(r);
 
1516
                return false;
 
1517
        }
 
1518
 
 
1519
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1520
        if (pull == NULL) {
 
1521
                talloc_free(r);
 
1522
                return false;
 
1523
        }
 
1524
 
 
1525
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1526
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1527
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1528
                talloc_free(r);
 
1529
                return false;
 
1530
        }
 
1531
 
 
1532
        if (DEBUGLEVEL >= 10) {
 
1533
                NDR_PRINT_IN_DEBUG(netr_LogonControl2Ex, r);
 
1534
        }
 
1535
 
 
1536
        ZERO_STRUCT(r->out);
 
1537
        r->out.query = talloc_zero(r, union netr_CONTROL_QUERY_INFORMATION);
 
1538
        if (r->out.query == NULL) {
 
1539
                talloc_free(r);
 
1540
                return false;
 
1541
        }
 
1542
 
 
1543
        r->out.result = _netr_LogonControl2Ex(p, r);
 
1544
 
 
1545
        if (p->rng_fault_state) {
 
1546
                talloc_free(r);
 
1547
                /* Return true here, srv_pipe_hnd.c will take care */
 
1548
                return true;
 
1549
        }
 
1550
 
 
1551
        if (DEBUGLEVEL >= 10) {
 
1552
                NDR_PRINT_OUT_DEBUG(netr_LogonControl2Ex, r);
 
1553
        }
 
1554
 
 
1555
        push = ndr_push_init_ctx(r, NULL);
 
1556
        if (push == NULL) {
 
1557
                talloc_free(r);
 
1558
                return false;
 
1559
        }
 
1560
 
 
1561
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1562
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1563
                talloc_free(r);
 
1564
                return false;
 
1565
        }
 
1566
 
 
1567
        blob = ndr_push_blob(push);
 
1568
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1569
                talloc_free(r);
 
1570
                return false;
 
1571
        }
 
1572
 
 
1573
        talloc_free(r);
 
1574
 
 
1575
        return true;
 
1576
}
 
1577
 
 
1578
static bool api_netr_NetrEnumerateTrustedDomains(pipes_struct *p)
 
1579
{
 
1580
        const struct ndr_interface_call *call;
 
1581
        struct ndr_pull *pull;
 
1582
        struct ndr_push *push;
 
1583
        enum ndr_err_code ndr_err;
 
1584
        DATA_BLOB blob;
 
1585
        struct netr_NetrEnumerateTrustedDomains *r;
 
1586
 
 
1587
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRENUMERATETRUSTEDDOMAINS];
 
1588
 
 
1589
        r = talloc(talloc_tos(), struct netr_NetrEnumerateTrustedDomains);
 
1590
        if (r == NULL) {
 
1591
                return false;
 
1592
        }
 
1593
 
 
1594
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1595
                talloc_free(r);
 
1596
                return false;
 
1597
        }
 
1598
 
 
1599
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1600
        if (pull == NULL) {
 
1601
                talloc_free(r);
 
1602
                return false;
 
1603
        }
 
1604
 
 
1605
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1606
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1607
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1608
                talloc_free(r);
 
1609
                return false;
 
1610
        }
 
1611
 
 
1612
        if (DEBUGLEVEL >= 10) {
 
1613
                NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomains, r);
 
1614
        }
 
1615
 
 
1616
        ZERO_STRUCT(r->out);
 
1617
        r->out.trusted_domains_blob = talloc_zero(r, struct netr_Blob);
 
1618
        if (r->out.trusted_domains_blob == NULL) {
 
1619
                talloc_free(r);
 
1620
                return false;
 
1621
        }
 
1622
 
 
1623
        r->out.result = _netr_NetrEnumerateTrustedDomains(p, r);
 
1624
 
 
1625
        if (p->rng_fault_state) {
 
1626
                talloc_free(r);
 
1627
                /* Return true here, srv_pipe_hnd.c will take care */
 
1628
                return true;
 
1629
        }
 
1630
 
 
1631
        if (DEBUGLEVEL >= 10) {
 
1632
                NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomains, r);
 
1633
        }
 
1634
 
 
1635
        push = ndr_push_init_ctx(r, NULL);
 
1636
        if (push == NULL) {
 
1637
                talloc_free(r);
 
1638
                return false;
 
1639
        }
 
1640
 
 
1641
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1642
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1643
                talloc_free(r);
 
1644
                return false;
 
1645
        }
 
1646
 
 
1647
        blob = ndr_push_blob(push);
 
1648
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1649
                talloc_free(r);
 
1650
                return false;
 
1651
        }
 
1652
 
 
1653
        talloc_free(r);
 
1654
 
 
1655
        return true;
 
1656
}
 
1657
 
 
1658
static bool api_netr_DsRGetDCName(pipes_struct *p)
 
1659
{
 
1660
        const struct ndr_interface_call *call;
 
1661
        struct ndr_pull *pull;
 
1662
        struct ndr_push *push;
 
1663
        enum ndr_err_code ndr_err;
 
1664
        DATA_BLOB blob;
 
1665
        struct netr_DsRGetDCName *r;
 
1666
 
 
1667
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETDCNAME];
 
1668
 
 
1669
        r = talloc(talloc_tos(), struct netr_DsRGetDCName);
 
1670
        if (r == NULL) {
 
1671
                return false;
 
1672
        }
 
1673
 
 
1674
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1675
                talloc_free(r);
 
1676
                return false;
 
1677
        }
 
1678
 
 
1679
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1680
        if (pull == NULL) {
 
1681
                talloc_free(r);
 
1682
                return false;
 
1683
        }
 
1684
 
 
1685
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1686
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1687
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1688
                talloc_free(r);
 
1689
                return false;
 
1690
        }
 
1691
 
 
1692
        if (DEBUGLEVEL >= 10) {
 
1693
                NDR_PRINT_IN_DEBUG(netr_DsRGetDCName, r);
 
1694
        }
 
1695
 
 
1696
        ZERO_STRUCT(r->out);
 
1697
        r->out.info = talloc_zero(r, struct netr_DsRGetDCNameInfo *);
 
1698
        if (r->out.info == NULL) {
 
1699
                talloc_free(r);
 
1700
                return false;
 
1701
        }
 
1702
 
 
1703
        r->out.result = _netr_DsRGetDCName(p, r);
 
1704
 
 
1705
        if (p->rng_fault_state) {
 
1706
                talloc_free(r);
 
1707
                /* Return true here, srv_pipe_hnd.c will take care */
 
1708
                return true;
 
1709
        }
 
1710
 
 
1711
        if (DEBUGLEVEL >= 10) {
 
1712
                NDR_PRINT_OUT_DEBUG(netr_DsRGetDCName, r);
 
1713
        }
 
1714
 
 
1715
        push = ndr_push_init_ctx(r, NULL);
 
1716
        if (push == NULL) {
 
1717
                talloc_free(r);
 
1718
                return false;
 
1719
        }
 
1720
 
 
1721
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1722
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1723
                talloc_free(r);
 
1724
                return false;
 
1725
        }
 
1726
 
 
1727
        blob = ndr_push_blob(push);
 
1728
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1729
                talloc_free(r);
 
1730
                return false;
 
1731
        }
 
1732
 
 
1733
        talloc_free(r);
 
1734
 
 
1735
        return true;
 
1736
}
 
1737
 
 
1738
static bool api_netr_LogonGetCapabilities(pipes_struct *p)
 
1739
{
 
1740
        const struct ndr_interface_call *call;
 
1741
        struct ndr_pull *pull;
 
1742
        struct ndr_push *push;
 
1743
        enum ndr_err_code ndr_err;
 
1744
        DATA_BLOB blob;
 
1745
        struct netr_LogonGetCapabilities *r;
 
1746
 
 
1747
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONGETCAPABILITIES];
 
1748
 
 
1749
        r = talloc(talloc_tos(), struct netr_LogonGetCapabilities);
 
1750
        if (r == NULL) {
 
1751
                return false;
 
1752
        }
 
1753
 
 
1754
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1755
                talloc_free(r);
 
1756
                return false;
 
1757
        }
 
1758
 
 
1759
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1760
        if (pull == NULL) {
 
1761
                talloc_free(r);
 
1762
                return false;
 
1763
        }
 
1764
 
 
1765
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1766
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1767
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1768
                talloc_free(r);
 
1769
                return false;
 
1770
        }
 
1771
 
 
1772
        if (DEBUGLEVEL >= 10) {
 
1773
                NDR_PRINT_IN_DEBUG(netr_LogonGetCapabilities, r);
 
1774
        }
 
1775
 
 
1776
        ZERO_STRUCT(r->out);
 
1777
        r->out.return_authenticator = r->in.return_authenticator;
 
1778
        r->out.capabilities = talloc_zero(r, union netr_Capabilities);
 
1779
        if (r->out.capabilities == NULL) {
 
1780
                talloc_free(r);
 
1781
                return false;
 
1782
        }
 
1783
 
 
1784
        r->out.result = _netr_LogonGetCapabilities(p, r);
 
1785
 
 
1786
        if (p->rng_fault_state) {
 
1787
                talloc_free(r);
 
1788
                /* Return true here, srv_pipe_hnd.c will take care */
 
1789
                return true;
 
1790
        }
 
1791
 
 
1792
        if (DEBUGLEVEL >= 10) {
 
1793
                NDR_PRINT_OUT_DEBUG(netr_LogonGetCapabilities, r);
 
1794
        }
 
1795
 
 
1796
        push = ndr_push_init_ctx(r, NULL);
 
1797
        if (push == NULL) {
 
1798
                talloc_free(r);
 
1799
                return false;
 
1800
        }
 
1801
 
 
1802
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1803
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1804
                talloc_free(r);
 
1805
                return false;
 
1806
        }
 
1807
 
 
1808
        blob = ndr_push_blob(push);
 
1809
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1810
                talloc_free(r);
 
1811
                return false;
 
1812
        }
 
1813
 
 
1814
        talloc_free(r);
 
1815
 
 
1816
        return true;
 
1817
}
 
1818
 
 
1819
static bool api_netr_NETRLOGONSETSERVICEBITS(pipes_struct *p)
 
1820
{
 
1821
        const struct ndr_interface_call *call;
 
1822
        struct ndr_pull *pull;
 
1823
        struct ndr_push *push;
 
1824
        enum ndr_err_code ndr_err;
 
1825
        DATA_BLOB blob;
 
1826
        struct netr_NETRLOGONSETSERVICEBITS *r;
 
1827
 
 
1828
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRLOGONSETSERVICEBITS];
 
1829
 
 
1830
        r = talloc(talloc_tos(), struct netr_NETRLOGONSETSERVICEBITS);
 
1831
        if (r == NULL) {
 
1832
                return false;
 
1833
        }
 
1834
 
 
1835
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1836
                talloc_free(r);
 
1837
                return false;
 
1838
        }
 
1839
 
 
1840
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1841
        if (pull == NULL) {
 
1842
                talloc_free(r);
 
1843
                return false;
 
1844
        }
 
1845
 
 
1846
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1847
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1848
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1849
                talloc_free(r);
 
1850
                return false;
 
1851
        }
 
1852
 
 
1853
        if (DEBUGLEVEL >= 10) {
 
1854
                NDR_PRINT_IN_DEBUG(netr_NETRLOGONSETSERVICEBITS, r);
 
1855
        }
 
1856
 
 
1857
        r->out.result = _netr_NETRLOGONSETSERVICEBITS(p, r);
 
1858
 
 
1859
        if (p->rng_fault_state) {
 
1860
                talloc_free(r);
 
1861
                /* Return true here, srv_pipe_hnd.c will take care */
 
1862
                return true;
 
1863
        }
 
1864
 
 
1865
        if (DEBUGLEVEL >= 10) {
 
1866
                NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSETSERVICEBITS, r);
 
1867
        }
 
1868
 
 
1869
        push = ndr_push_init_ctx(r, NULL);
 
1870
        if (push == NULL) {
 
1871
                talloc_free(r);
 
1872
                return false;
 
1873
        }
 
1874
 
 
1875
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1876
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1877
                talloc_free(r);
 
1878
                return false;
 
1879
        }
 
1880
 
 
1881
        blob = ndr_push_blob(push);
 
1882
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1883
                talloc_free(r);
 
1884
                return false;
 
1885
        }
 
1886
 
 
1887
        talloc_free(r);
 
1888
 
 
1889
        return true;
 
1890
}
 
1891
 
 
1892
static bool api_netr_LogonGetTrustRid(pipes_struct *p)
 
1893
{
 
1894
        const struct ndr_interface_call *call;
 
1895
        struct ndr_pull *pull;
 
1896
        struct ndr_push *push;
 
1897
        enum ndr_err_code ndr_err;
 
1898
        DATA_BLOB blob;
 
1899
        struct netr_LogonGetTrustRid *r;
 
1900
 
 
1901
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONGETTRUSTRID];
 
1902
 
 
1903
        r = talloc(talloc_tos(), struct netr_LogonGetTrustRid);
 
1904
        if (r == NULL) {
 
1905
                return false;
 
1906
        }
 
1907
 
 
1908
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1909
                talloc_free(r);
 
1910
                return false;
 
1911
        }
 
1912
 
 
1913
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1914
        if (pull == NULL) {
 
1915
                talloc_free(r);
 
1916
                return false;
 
1917
        }
 
1918
 
 
1919
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1920
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1921
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1922
                talloc_free(r);
 
1923
                return false;
 
1924
        }
 
1925
 
 
1926
        if (DEBUGLEVEL >= 10) {
 
1927
                NDR_PRINT_IN_DEBUG(netr_LogonGetTrustRid, r);
 
1928
        }
 
1929
 
 
1930
        ZERO_STRUCT(r->out);
 
1931
        r->out.rid = talloc_zero(r, uint32_t);
 
1932
        if (r->out.rid == NULL) {
 
1933
                talloc_free(r);
 
1934
                return false;
 
1935
        }
 
1936
 
 
1937
        r->out.result = _netr_LogonGetTrustRid(p, r);
 
1938
 
 
1939
        if (p->rng_fault_state) {
 
1940
                talloc_free(r);
 
1941
                /* Return true here, srv_pipe_hnd.c will take care */
 
1942
                return true;
 
1943
        }
 
1944
 
 
1945
        if (DEBUGLEVEL >= 10) {
 
1946
                NDR_PRINT_OUT_DEBUG(netr_LogonGetTrustRid, r);
 
1947
        }
 
1948
 
 
1949
        push = ndr_push_init_ctx(r, NULL);
 
1950
        if (push == NULL) {
 
1951
                talloc_free(r);
 
1952
                return false;
 
1953
        }
 
1954
 
 
1955
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1956
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1957
                talloc_free(r);
 
1958
                return false;
 
1959
        }
 
1960
 
 
1961
        blob = ndr_push_blob(push);
 
1962
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
1963
                talloc_free(r);
 
1964
                return false;
 
1965
        }
 
1966
 
 
1967
        talloc_free(r);
 
1968
 
 
1969
        return true;
 
1970
}
 
1971
 
 
1972
static bool api_netr_NETRLOGONCOMPUTESERVERDIGEST(pipes_struct *p)
 
1973
{
 
1974
        const struct ndr_interface_call *call;
 
1975
        struct ndr_pull *pull;
 
1976
        struct ndr_push *push;
 
1977
        enum ndr_err_code ndr_err;
 
1978
        DATA_BLOB blob;
 
1979
        struct netr_NETRLOGONCOMPUTESERVERDIGEST *r;
 
1980
 
 
1981
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST];
 
1982
 
 
1983
        r = talloc(talloc_tos(), struct netr_NETRLOGONCOMPUTESERVERDIGEST);
 
1984
        if (r == NULL) {
 
1985
                return false;
 
1986
        }
 
1987
 
 
1988
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
1989
                talloc_free(r);
 
1990
                return false;
 
1991
        }
 
1992
 
 
1993
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
1994
        if (pull == NULL) {
 
1995
                talloc_free(r);
 
1996
                return false;
 
1997
        }
 
1998
 
 
1999
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2000
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2001
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2002
                talloc_free(r);
 
2003
                return false;
 
2004
        }
 
2005
 
 
2006
        if (DEBUGLEVEL >= 10) {
 
2007
                NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, r);
 
2008
        }
 
2009
 
 
2010
        r->out.result = _netr_NETRLOGONCOMPUTESERVERDIGEST(p, r);
 
2011
 
 
2012
        if (p->rng_fault_state) {
 
2013
                talloc_free(r);
 
2014
                /* Return true here, srv_pipe_hnd.c will take care */
 
2015
                return true;
 
2016
        }
 
2017
 
 
2018
        if (DEBUGLEVEL >= 10) {
 
2019
                NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, r);
 
2020
        }
 
2021
 
 
2022
        push = ndr_push_init_ctx(r, NULL);
 
2023
        if (push == NULL) {
 
2024
                talloc_free(r);
 
2025
                return false;
 
2026
        }
 
2027
 
 
2028
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2029
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2030
                talloc_free(r);
 
2031
                return false;
 
2032
        }
 
2033
 
 
2034
        blob = ndr_push_blob(push);
 
2035
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2036
                talloc_free(r);
 
2037
                return false;
 
2038
        }
 
2039
 
 
2040
        talloc_free(r);
 
2041
 
 
2042
        return true;
 
2043
}
 
2044
 
 
2045
static bool api_netr_NETRLOGONCOMPUTECLIENTDIGEST(pipes_struct *p)
 
2046
{
 
2047
        const struct ndr_interface_call *call;
 
2048
        struct ndr_pull *pull;
 
2049
        struct ndr_push *push;
 
2050
        enum ndr_err_code ndr_err;
 
2051
        DATA_BLOB blob;
 
2052
        struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r;
 
2053
 
 
2054
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST];
 
2055
 
 
2056
        r = talloc(talloc_tos(), struct netr_NETRLOGONCOMPUTECLIENTDIGEST);
 
2057
        if (r == NULL) {
 
2058
                return false;
 
2059
        }
 
2060
 
 
2061
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2062
                talloc_free(r);
 
2063
                return false;
 
2064
        }
 
2065
 
 
2066
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2067
        if (pull == NULL) {
 
2068
                talloc_free(r);
 
2069
                return false;
 
2070
        }
 
2071
 
 
2072
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2073
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2074
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2075
                talloc_free(r);
 
2076
                return false;
 
2077
        }
 
2078
 
 
2079
        if (DEBUGLEVEL >= 10) {
 
2080
                NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, r);
 
2081
        }
 
2082
 
 
2083
        r->out.result = _netr_NETRLOGONCOMPUTECLIENTDIGEST(p, r);
 
2084
 
 
2085
        if (p->rng_fault_state) {
 
2086
                talloc_free(r);
 
2087
                /* Return true here, srv_pipe_hnd.c will take care */
 
2088
                return true;
 
2089
        }
 
2090
 
 
2091
        if (DEBUGLEVEL >= 10) {
 
2092
                NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, r);
 
2093
        }
 
2094
 
 
2095
        push = ndr_push_init_ctx(r, NULL);
 
2096
        if (push == NULL) {
 
2097
                talloc_free(r);
 
2098
                return false;
 
2099
        }
 
2100
 
 
2101
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2102
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2103
                talloc_free(r);
 
2104
                return false;
 
2105
        }
 
2106
 
 
2107
        blob = ndr_push_blob(push);
 
2108
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2109
                talloc_free(r);
 
2110
                return false;
 
2111
        }
 
2112
 
 
2113
        talloc_free(r);
 
2114
 
 
2115
        return true;
 
2116
}
 
2117
 
 
2118
static bool api_netr_ServerAuthenticate3(pipes_struct *p)
 
2119
{
 
2120
        const struct ndr_interface_call *call;
 
2121
        struct ndr_pull *pull;
 
2122
        struct ndr_push *push;
 
2123
        enum ndr_err_code ndr_err;
 
2124
        DATA_BLOB blob;
 
2125
        struct netr_ServerAuthenticate3 *r;
 
2126
 
 
2127
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERAUTHENTICATE3];
 
2128
 
 
2129
        r = talloc(talloc_tos(), struct netr_ServerAuthenticate3);
 
2130
        if (r == NULL) {
 
2131
                return false;
 
2132
        }
 
2133
 
 
2134
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2135
                talloc_free(r);
 
2136
                return false;
 
2137
        }
 
2138
 
 
2139
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2140
        if (pull == NULL) {
 
2141
                talloc_free(r);
 
2142
                return false;
 
2143
        }
 
2144
 
 
2145
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2146
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2147
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2148
                talloc_free(r);
 
2149
                return false;
 
2150
        }
 
2151
 
 
2152
        if (DEBUGLEVEL >= 10) {
 
2153
                NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate3, r);
 
2154
        }
 
2155
 
 
2156
        ZERO_STRUCT(r->out);
 
2157
        r->out.negotiate_flags = r->in.negotiate_flags;
 
2158
        r->out.return_credentials = talloc_zero(r, struct netr_Credential);
 
2159
        if (r->out.return_credentials == NULL) {
 
2160
                talloc_free(r);
 
2161
                return false;
 
2162
        }
 
2163
 
 
2164
        r->out.rid = talloc_zero(r, uint32_t);
 
2165
        if (r->out.rid == NULL) {
 
2166
                talloc_free(r);
 
2167
                return false;
 
2168
        }
 
2169
 
 
2170
        r->out.result = _netr_ServerAuthenticate3(p, r);
 
2171
 
 
2172
        if (p->rng_fault_state) {
 
2173
                talloc_free(r);
 
2174
                /* Return true here, srv_pipe_hnd.c will take care */
 
2175
                return true;
 
2176
        }
 
2177
 
 
2178
        if (DEBUGLEVEL >= 10) {
 
2179
                NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3, r);
 
2180
        }
 
2181
 
 
2182
        push = ndr_push_init_ctx(r, NULL);
 
2183
        if (push == NULL) {
 
2184
                talloc_free(r);
 
2185
                return false;
 
2186
        }
 
2187
 
 
2188
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2189
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2190
                talloc_free(r);
 
2191
                return false;
 
2192
        }
 
2193
 
 
2194
        blob = ndr_push_blob(push);
 
2195
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2196
                talloc_free(r);
 
2197
                return false;
 
2198
        }
 
2199
 
 
2200
        talloc_free(r);
 
2201
 
 
2202
        return true;
 
2203
}
 
2204
 
 
2205
static bool api_netr_DsRGetDCNameEx(pipes_struct *p)
 
2206
{
 
2207
        const struct ndr_interface_call *call;
 
2208
        struct ndr_pull *pull;
 
2209
        struct ndr_push *push;
 
2210
        enum ndr_err_code ndr_err;
 
2211
        DATA_BLOB blob;
 
2212
        struct netr_DsRGetDCNameEx *r;
 
2213
 
 
2214
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETDCNAMEEX];
 
2215
 
 
2216
        r = talloc(talloc_tos(), struct netr_DsRGetDCNameEx);
 
2217
        if (r == NULL) {
 
2218
                return false;
 
2219
        }
 
2220
 
 
2221
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2222
                talloc_free(r);
 
2223
                return false;
 
2224
        }
 
2225
 
 
2226
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2227
        if (pull == NULL) {
 
2228
                talloc_free(r);
 
2229
                return false;
 
2230
        }
 
2231
 
 
2232
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2233
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2234
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2235
                talloc_free(r);
 
2236
                return false;
 
2237
        }
 
2238
 
 
2239
        if (DEBUGLEVEL >= 10) {
 
2240
                NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx, r);
 
2241
        }
 
2242
 
 
2243
        ZERO_STRUCT(r->out);
 
2244
        r->out.info = talloc_zero(r, struct netr_DsRGetDCNameInfo *);
 
2245
        if (r->out.info == NULL) {
 
2246
                talloc_free(r);
 
2247
                return false;
 
2248
        }
 
2249
 
 
2250
        r->out.result = _netr_DsRGetDCNameEx(p, r);
 
2251
 
 
2252
        if (p->rng_fault_state) {
 
2253
                talloc_free(r);
 
2254
                /* Return true here, srv_pipe_hnd.c will take care */
 
2255
                return true;
 
2256
        }
 
2257
 
 
2258
        if (DEBUGLEVEL >= 10) {
 
2259
                NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx, r);
 
2260
        }
 
2261
 
 
2262
        push = ndr_push_init_ctx(r, NULL);
 
2263
        if (push == NULL) {
 
2264
                talloc_free(r);
 
2265
                return false;
 
2266
        }
 
2267
 
 
2268
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2269
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2270
                talloc_free(r);
 
2271
                return false;
 
2272
        }
 
2273
 
 
2274
        blob = ndr_push_blob(push);
 
2275
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2276
                talloc_free(r);
 
2277
                return false;
 
2278
        }
 
2279
 
 
2280
        talloc_free(r);
 
2281
 
 
2282
        return true;
 
2283
}
 
2284
 
 
2285
static bool api_netr_DsRGetSiteName(pipes_struct *p)
 
2286
{
 
2287
        const struct ndr_interface_call *call;
 
2288
        struct ndr_pull *pull;
 
2289
        struct ndr_push *push;
 
2290
        enum ndr_err_code ndr_err;
 
2291
        DATA_BLOB blob;
 
2292
        struct netr_DsRGetSiteName *r;
 
2293
 
 
2294
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETSITENAME];
 
2295
 
 
2296
        r = talloc(talloc_tos(), struct netr_DsRGetSiteName);
 
2297
        if (r == NULL) {
 
2298
                return false;
 
2299
        }
 
2300
 
 
2301
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2302
                talloc_free(r);
 
2303
                return false;
 
2304
        }
 
2305
 
 
2306
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2307
        if (pull == NULL) {
 
2308
                talloc_free(r);
 
2309
                return false;
 
2310
        }
 
2311
 
 
2312
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2313
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2314
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2315
                talloc_free(r);
 
2316
                return false;
 
2317
        }
 
2318
 
 
2319
        if (DEBUGLEVEL >= 10) {
 
2320
                NDR_PRINT_IN_DEBUG(netr_DsRGetSiteName, r);
 
2321
        }
 
2322
 
 
2323
        ZERO_STRUCT(r->out);
 
2324
        r->out.site = talloc_zero(r, const char *);
 
2325
        if (r->out.site == NULL) {
 
2326
                talloc_free(r);
 
2327
                return false;
 
2328
        }
 
2329
 
 
2330
        r->out.result = _netr_DsRGetSiteName(p, r);
 
2331
 
 
2332
        if (p->rng_fault_state) {
 
2333
                talloc_free(r);
 
2334
                /* Return true here, srv_pipe_hnd.c will take care */
 
2335
                return true;
 
2336
        }
 
2337
 
 
2338
        if (DEBUGLEVEL >= 10) {
 
2339
                NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName, r);
 
2340
        }
 
2341
 
 
2342
        push = ndr_push_init_ctx(r, NULL);
 
2343
        if (push == NULL) {
 
2344
                talloc_free(r);
 
2345
                return false;
 
2346
        }
 
2347
 
 
2348
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2349
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2350
                talloc_free(r);
 
2351
                return false;
 
2352
        }
 
2353
 
 
2354
        blob = ndr_push_blob(push);
 
2355
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2356
                talloc_free(r);
 
2357
                return false;
 
2358
        }
 
2359
 
 
2360
        talloc_free(r);
 
2361
 
 
2362
        return true;
 
2363
}
 
2364
 
 
2365
static bool api_netr_LogonGetDomainInfo(pipes_struct *p)
 
2366
{
 
2367
        const struct ndr_interface_call *call;
 
2368
        struct ndr_pull *pull;
 
2369
        struct ndr_push *push;
 
2370
        enum ndr_err_code ndr_err;
 
2371
        DATA_BLOB blob;
 
2372
        struct netr_LogonGetDomainInfo *r;
 
2373
 
 
2374
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONGETDOMAININFO];
 
2375
 
 
2376
        r = talloc(talloc_tos(), struct netr_LogonGetDomainInfo);
 
2377
        if (r == NULL) {
 
2378
                return false;
 
2379
        }
 
2380
 
 
2381
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2382
                talloc_free(r);
 
2383
                return false;
 
2384
        }
 
2385
 
 
2386
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2387
        if (pull == NULL) {
 
2388
                talloc_free(r);
 
2389
                return false;
 
2390
        }
 
2391
 
 
2392
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2393
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2394
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2395
                talloc_free(r);
 
2396
                return false;
 
2397
        }
 
2398
 
 
2399
        if (DEBUGLEVEL >= 10) {
 
2400
                NDR_PRINT_IN_DEBUG(netr_LogonGetDomainInfo, r);
 
2401
        }
 
2402
 
 
2403
        ZERO_STRUCT(r->out);
 
2404
        r->out.return_authenticator = r->in.return_authenticator;
 
2405
        r->out.info = talloc_zero(r, union netr_DomainInfo);
 
2406
        if (r->out.info == NULL) {
 
2407
                talloc_free(r);
 
2408
                return false;
 
2409
        }
 
2410
 
 
2411
        r->out.result = _netr_LogonGetDomainInfo(p, r);
 
2412
 
 
2413
        if (p->rng_fault_state) {
 
2414
                talloc_free(r);
 
2415
                /* Return true here, srv_pipe_hnd.c will take care */
 
2416
                return true;
 
2417
        }
 
2418
 
 
2419
        if (DEBUGLEVEL >= 10) {
 
2420
                NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo, r);
 
2421
        }
 
2422
 
 
2423
        push = ndr_push_init_ctx(r, NULL);
 
2424
        if (push == NULL) {
 
2425
                talloc_free(r);
 
2426
                return false;
 
2427
        }
 
2428
 
 
2429
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2430
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2431
                talloc_free(r);
 
2432
                return false;
 
2433
        }
 
2434
 
 
2435
        blob = ndr_push_blob(push);
 
2436
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2437
                talloc_free(r);
 
2438
                return false;
 
2439
        }
 
2440
 
 
2441
        talloc_free(r);
 
2442
 
 
2443
        return true;
 
2444
}
 
2445
 
 
2446
static bool api_netr_ServerPasswordSet2(pipes_struct *p)
 
2447
{
 
2448
        const struct ndr_interface_call *call;
 
2449
        struct ndr_pull *pull;
 
2450
        struct ndr_push *push;
 
2451
        enum ndr_err_code ndr_err;
 
2452
        DATA_BLOB blob;
 
2453
        struct netr_ServerPasswordSet2 *r;
 
2454
 
 
2455
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERPASSWORDSET2];
 
2456
 
 
2457
        r = talloc(talloc_tos(), struct netr_ServerPasswordSet2);
 
2458
        if (r == NULL) {
 
2459
                return false;
 
2460
        }
 
2461
 
 
2462
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2463
                talloc_free(r);
 
2464
                return false;
 
2465
        }
 
2466
 
 
2467
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2468
        if (pull == NULL) {
 
2469
                talloc_free(r);
 
2470
                return false;
 
2471
        }
 
2472
 
 
2473
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2474
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2475
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2476
                talloc_free(r);
 
2477
                return false;
 
2478
        }
 
2479
 
 
2480
        if (DEBUGLEVEL >= 10) {
 
2481
                NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet2, r);
 
2482
        }
 
2483
 
 
2484
        ZERO_STRUCT(r->out);
 
2485
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
2486
        if (r->out.return_authenticator == NULL) {
 
2487
                talloc_free(r);
 
2488
                return false;
 
2489
        }
 
2490
 
 
2491
        r->out.result = _netr_ServerPasswordSet2(p, r);
 
2492
 
 
2493
        if (p->rng_fault_state) {
 
2494
                talloc_free(r);
 
2495
                /* Return true here, srv_pipe_hnd.c will take care */
 
2496
                return true;
 
2497
        }
 
2498
 
 
2499
        if (DEBUGLEVEL >= 10) {
 
2500
                NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2, r);
 
2501
        }
 
2502
 
 
2503
        push = ndr_push_init_ctx(r, NULL);
 
2504
        if (push == NULL) {
 
2505
                talloc_free(r);
 
2506
                return false;
 
2507
        }
 
2508
 
 
2509
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2510
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2511
                talloc_free(r);
 
2512
                return false;
 
2513
        }
 
2514
 
 
2515
        blob = ndr_push_blob(push);
 
2516
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2517
                talloc_free(r);
 
2518
                return false;
 
2519
        }
 
2520
 
 
2521
        talloc_free(r);
 
2522
 
 
2523
        return true;
 
2524
}
 
2525
 
 
2526
static bool api_netr_ServerPasswordGet(pipes_struct *p)
 
2527
{
 
2528
        const struct ndr_interface_call *call;
 
2529
        struct ndr_pull *pull;
 
2530
        struct ndr_push *push;
 
2531
        enum ndr_err_code ndr_err;
 
2532
        DATA_BLOB blob;
 
2533
        struct netr_ServerPasswordGet *r;
 
2534
 
 
2535
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERPASSWORDGET];
 
2536
 
 
2537
        r = talloc(talloc_tos(), struct netr_ServerPasswordGet);
 
2538
        if (r == NULL) {
 
2539
                return false;
 
2540
        }
 
2541
 
 
2542
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2543
                talloc_free(r);
 
2544
                return false;
 
2545
        }
 
2546
 
 
2547
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2548
        if (pull == NULL) {
 
2549
                talloc_free(r);
 
2550
                return false;
 
2551
        }
 
2552
 
 
2553
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2554
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2555
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2556
                talloc_free(r);
 
2557
                return false;
 
2558
        }
 
2559
 
 
2560
        if (DEBUGLEVEL >= 10) {
 
2561
                NDR_PRINT_IN_DEBUG(netr_ServerPasswordGet, r);
 
2562
        }
 
2563
 
 
2564
        ZERO_STRUCT(r->out);
 
2565
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
2566
        if (r->out.return_authenticator == NULL) {
 
2567
                talloc_free(r);
 
2568
                return false;
 
2569
        }
 
2570
 
 
2571
        r->out.password = talloc_zero(r, struct samr_Password);
 
2572
        if (r->out.password == NULL) {
 
2573
                talloc_free(r);
 
2574
                return false;
 
2575
        }
 
2576
 
 
2577
        r->out.result = _netr_ServerPasswordGet(p, r);
 
2578
 
 
2579
        if (p->rng_fault_state) {
 
2580
                talloc_free(r);
 
2581
                /* Return true here, srv_pipe_hnd.c will take care */
 
2582
                return true;
 
2583
        }
 
2584
 
 
2585
        if (DEBUGLEVEL >= 10) {
 
2586
                NDR_PRINT_OUT_DEBUG(netr_ServerPasswordGet, r);
 
2587
        }
 
2588
 
 
2589
        push = ndr_push_init_ctx(r, NULL);
 
2590
        if (push == NULL) {
 
2591
                talloc_free(r);
 
2592
                return false;
 
2593
        }
 
2594
 
 
2595
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2596
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2597
                talloc_free(r);
 
2598
                return false;
 
2599
        }
 
2600
 
 
2601
        blob = ndr_push_blob(push);
 
2602
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2603
                talloc_free(r);
 
2604
                return false;
 
2605
        }
 
2606
 
 
2607
        talloc_free(r);
 
2608
 
 
2609
        return true;
 
2610
}
 
2611
 
 
2612
static bool api_netr_NETRLOGONSENDTOSAM(pipes_struct *p)
 
2613
{
 
2614
        const struct ndr_interface_call *call;
 
2615
        struct ndr_pull *pull;
 
2616
        struct ndr_push *push;
 
2617
        enum ndr_err_code ndr_err;
 
2618
        DATA_BLOB blob;
 
2619
        struct netr_NETRLOGONSENDTOSAM *r;
 
2620
 
 
2621
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRLOGONSENDTOSAM];
 
2622
 
 
2623
        r = talloc(talloc_tos(), struct netr_NETRLOGONSENDTOSAM);
 
2624
        if (r == NULL) {
 
2625
                return false;
 
2626
        }
 
2627
 
 
2628
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2629
                talloc_free(r);
 
2630
                return false;
 
2631
        }
 
2632
 
 
2633
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2634
        if (pull == NULL) {
 
2635
                talloc_free(r);
 
2636
                return false;
 
2637
        }
 
2638
 
 
2639
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2640
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2641
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2642
                talloc_free(r);
 
2643
                return false;
 
2644
        }
 
2645
 
 
2646
        if (DEBUGLEVEL >= 10) {
 
2647
                NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM, r);
 
2648
        }
 
2649
 
 
2650
        r->out.result = _netr_NETRLOGONSENDTOSAM(p, r);
 
2651
 
 
2652
        if (p->rng_fault_state) {
 
2653
                talloc_free(r);
 
2654
                /* Return true here, srv_pipe_hnd.c will take care */
 
2655
                return true;
 
2656
        }
 
2657
 
 
2658
        if (DEBUGLEVEL >= 10) {
 
2659
                NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM, r);
 
2660
        }
 
2661
 
 
2662
        push = ndr_push_init_ctx(r, NULL);
 
2663
        if (push == NULL) {
 
2664
                talloc_free(r);
 
2665
                return false;
 
2666
        }
 
2667
 
 
2668
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2669
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2670
                talloc_free(r);
 
2671
                return false;
 
2672
        }
 
2673
 
 
2674
        blob = ndr_push_blob(push);
 
2675
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2676
                talloc_free(r);
 
2677
                return false;
 
2678
        }
 
2679
 
 
2680
        talloc_free(r);
 
2681
 
 
2682
        return true;
 
2683
}
 
2684
 
 
2685
static bool api_netr_DsRAddressToSitenamesW(pipes_struct *p)
 
2686
{
 
2687
        const struct ndr_interface_call *call;
 
2688
        struct ndr_pull *pull;
 
2689
        struct ndr_push *push;
 
2690
        enum ndr_err_code ndr_err;
 
2691
        DATA_BLOB blob;
 
2692
        struct netr_DsRAddressToSitenamesW *r;
 
2693
 
 
2694
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRADDRESSTOSITENAMESW];
 
2695
 
 
2696
        r = talloc(talloc_tos(), struct netr_DsRAddressToSitenamesW);
 
2697
        if (r == NULL) {
 
2698
                return false;
 
2699
        }
 
2700
 
 
2701
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2702
                talloc_free(r);
 
2703
                return false;
 
2704
        }
 
2705
 
 
2706
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2707
        if (pull == NULL) {
 
2708
                talloc_free(r);
 
2709
                return false;
 
2710
        }
 
2711
 
 
2712
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2713
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2714
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2715
                talloc_free(r);
 
2716
                return false;
 
2717
        }
 
2718
 
 
2719
        if (DEBUGLEVEL >= 10) {
 
2720
                NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesW, r);
 
2721
        }
 
2722
 
 
2723
        ZERO_STRUCT(r->out);
 
2724
        r->out.ctr = talloc_zero(r, struct netr_DsRAddressToSitenamesWCtr *);
 
2725
        if (r->out.ctr == NULL) {
 
2726
                talloc_free(r);
 
2727
                return false;
 
2728
        }
 
2729
 
 
2730
        r->out.result = _netr_DsRAddressToSitenamesW(p, r);
 
2731
 
 
2732
        if (p->rng_fault_state) {
 
2733
                talloc_free(r);
 
2734
                /* Return true here, srv_pipe_hnd.c will take care */
 
2735
                return true;
 
2736
        }
 
2737
 
 
2738
        if (DEBUGLEVEL >= 10) {
 
2739
                NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesW, r);
 
2740
        }
 
2741
 
 
2742
        push = ndr_push_init_ctx(r, NULL);
 
2743
        if (push == NULL) {
 
2744
                talloc_free(r);
 
2745
                return false;
 
2746
        }
 
2747
 
 
2748
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2749
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2750
                talloc_free(r);
 
2751
                return false;
 
2752
        }
 
2753
 
 
2754
        blob = ndr_push_blob(push);
 
2755
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2756
                talloc_free(r);
 
2757
                return false;
 
2758
        }
 
2759
 
 
2760
        talloc_free(r);
 
2761
 
 
2762
        return true;
 
2763
}
 
2764
 
 
2765
static bool api_netr_DsRGetDCNameEx2(pipes_struct *p)
 
2766
{
 
2767
        const struct ndr_interface_call *call;
 
2768
        struct ndr_pull *pull;
 
2769
        struct ndr_push *push;
 
2770
        enum ndr_err_code ndr_err;
 
2771
        DATA_BLOB blob;
 
2772
        struct netr_DsRGetDCNameEx2 *r;
 
2773
 
 
2774
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETDCNAMEEX2];
 
2775
 
 
2776
        r = talloc(talloc_tos(), struct netr_DsRGetDCNameEx2);
 
2777
        if (r == NULL) {
 
2778
                return false;
 
2779
        }
 
2780
 
 
2781
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2782
                talloc_free(r);
 
2783
                return false;
 
2784
        }
 
2785
 
 
2786
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2787
        if (pull == NULL) {
 
2788
                talloc_free(r);
 
2789
                return false;
 
2790
        }
 
2791
 
 
2792
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2793
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2794
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2795
                talloc_free(r);
 
2796
                return false;
 
2797
        }
 
2798
 
 
2799
        if (DEBUGLEVEL >= 10) {
 
2800
                NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx2, r);
 
2801
        }
 
2802
 
 
2803
        ZERO_STRUCT(r->out);
 
2804
        r->out.info = talloc_zero(r, struct netr_DsRGetDCNameInfo *);
 
2805
        if (r->out.info == NULL) {
 
2806
                talloc_free(r);
 
2807
                return false;
 
2808
        }
 
2809
 
 
2810
        r->out.result = _netr_DsRGetDCNameEx2(p, r);
 
2811
 
 
2812
        if (p->rng_fault_state) {
 
2813
                talloc_free(r);
 
2814
                /* Return true here, srv_pipe_hnd.c will take care */
 
2815
                return true;
 
2816
        }
 
2817
 
 
2818
        if (DEBUGLEVEL >= 10) {
 
2819
                NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2, r);
 
2820
        }
 
2821
 
 
2822
        push = ndr_push_init_ctx(r, NULL);
 
2823
        if (push == NULL) {
 
2824
                talloc_free(r);
 
2825
                return false;
 
2826
        }
 
2827
 
 
2828
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2829
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2830
                talloc_free(r);
 
2831
                return false;
 
2832
        }
 
2833
 
 
2834
        blob = ndr_push_blob(push);
 
2835
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2836
                talloc_free(r);
 
2837
                return false;
 
2838
        }
 
2839
 
 
2840
        talloc_free(r);
 
2841
 
 
2842
        return true;
 
2843
}
 
2844
 
 
2845
static bool api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(pipes_struct *p)
 
2846
{
 
2847
        const struct ndr_interface_call *call;
 
2848
        struct ndr_pull *pull;
 
2849
        struct ndr_push *push;
 
2850
        enum ndr_err_code ndr_err;
 
2851
        DATA_BLOB blob;
 
2852
        struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r;
 
2853
 
 
2854
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN];
 
2855
 
 
2856
        r = talloc(talloc_tos(), struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN);
 
2857
        if (r == NULL) {
 
2858
                return false;
 
2859
        }
 
2860
 
 
2861
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2862
                talloc_free(r);
 
2863
                return false;
 
2864
        }
 
2865
 
 
2866
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2867
        if (pull == NULL) {
 
2868
                talloc_free(r);
 
2869
                return false;
 
2870
        }
 
2871
 
 
2872
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2873
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2874
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2875
                talloc_free(r);
 
2876
                return false;
 
2877
        }
 
2878
 
 
2879
        if (DEBUGLEVEL >= 10) {
 
2880
                NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, r);
 
2881
        }
 
2882
 
 
2883
        r->out.result = _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(p, r);
 
2884
 
 
2885
        if (p->rng_fault_state) {
 
2886
                talloc_free(r);
 
2887
                /* Return true here, srv_pipe_hnd.c will take care */
 
2888
                return true;
 
2889
        }
 
2890
 
 
2891
        if (DEBUGLEVEL >= 10) {
 
2892
                NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, r);
 
2893
        }
 
2894
 
 
2895
        push = ndr_push_init_ctx(r, NULL);
 
2896
        if (push == NULL) {
 
2897
                talloc_free(r);
 
2898
                return false;
 
2899
        }
 
2900
 
 
2901
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2902
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2903
                talloc_free(r);
 
2904
                return false;
 
2905
        }
 
2906
 
 
2907
        blob = ndr_push_blob(push);
 
2908
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2909
                talloc_free(r);
 
2910
                return false;
 
2911
        }
 
2912
 
 
2913
        talloc_free(r);
 
2914
 
 
2915
        return true;
 
2916
}
 
2917
 
 
2918
static bool api_netr_NetrEnumerateTrustedDomainsEx(pipes_struct *p)
 
2919
{
 
2920
        const struct ndr_interface_call *call;
 
2921
        struct ndr_pull *pull;
 
2922
        struct ndr_push *push;
 
2923
        enum ndr_err_code ndr_err;
 
2924
        DATA_BLOB blob;
 
2925
        struct netr_NetrEnumerateTrustedDomainsEx *r;
 
2926
 
 
2927
        call = &ndr_table_netlogon.calls[NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX];
 
2928
 
 
2929
        r = talloc(talloc_tos(), struct netr_NetrEnumerateTrustedDomainsEx);
 
2930
        if (r == NULL) {
 
2931
                return false;
 
2932
        }
 
2933
 
 
2934
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
2935
                talloc_free(r);
 
2936
                return false;
 
2937
        }
 
2938
 
 
2939
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
2940
        if (pull == NULL) {
 
2941
                talloc_free(r);
 
2942
                return false;
 
2943
        }
 
2944
 
 
2945
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2946
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2947
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2948
                talloc_free(r);
 
2949
                return false;
 
2950
        }
 
2951
 
 
2952
        if (DEBUGLEVEL >= 10) {
 
2953
                NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomainsEx, r);
 
2954
        }
 
2955
 
 
2956
        ZERO_STRUCT(r->out);
 
2957
        r->out.dom_trust_list = talloc_zero(r, struct netr_DomainTrustList);
 
2958
        if (r->out.dom_trust_list == NULL) {
 
2959
                talloc_free(r);
 
2960
                return false;
 
2961
        }
 
2962
 
 
2963
        r->out.result = _netr_NetrEnumerateTrustedDomainsEx(p, r);
 
2964
 
 
2965
        if (p->rng_fault_state) {
 
2966
                talloc_free(r);
 
2967
                /* Return true here, srv_pipe_hnd.c will take care */
 
2968
                return true;
 
2969
        }
 
2970
 
 
2971
        if (DEBUGLEVEL >= 10) {
 
2972
                NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomainsEx, r);
 
2973
        }
 
2974
 
 
2975
        push = ndr_push_init_ctx(r, NULL);
 
2976
        if (push == NULL) {
 
2977
                talloc_free(r);
 
2978
                return false;
 
2979
        }
 
2980
 
 
2981
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2982
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2983
                talloc_free(r);
 
2984
                return false;
 
2985
        }
 
2986
 
 
2987
        blob = ndr_push_blob(push);
 
2988
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
2989
                talloc_free(r);
 
2990
                return false;
 
2991
        }
 
2992
 
 
2993
        talloc_free(r);
 
2994
 
 
2995
        return true;
 
2996
}
 
2997
 
 
2998
static bool api_netr_DsRAddressToSitenamesExW(pipes_struct *p)
 
2999
{
 
3000
        const struct ndr_interface_call *call;
 
3001
        struct ndr_pull *pull;
 
3002
        struct ndr_push *push;
 
3003
        enum ndr_err_code ndr_err;
 
3004
        DATA_BLOB blob;
 
3005
        struct netr_DsRAddressToSitenamesExW *r;
 
3006
 
 
3007
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRADDRESSTOSITENAMESEXW];
 
3008
 
 
3009
        r = talloc(talloc_tos(), struct netr_DsRAddressToSitenamesExW);
 
3010
        if (r == NULL) {
 
3011
                return false;
 
3012
        }
 
3013
 
 
3014
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3015
                talloc_free(r);
 
3016
                return false;
 
3017
        }
 
3018
 
 
3019
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3020
        if (pull == NULL) {
 
3021
                talloc_free(r);
 
3022
                return false;
 
3023
        }
 
3024
 
 
3025
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3026
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3027
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3028
                talloc_free(r);
 
3029
                return false;
 
3030
        }
 
3031
 
 
3032
        if (DEBUGLEVEL >= 10) {
 
3033
                NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesExW, r);
 
3034
        }
 
3035
 
 
3036
        ZERO_STRUCT(r->out);
 
3037
        r->out.ctr = talloc_zero(r, struct netr_DsRAddressToSitenamesExWCtr *);
 
3038
        if (r->out.ctr == NULL) {
 
3039
                talloc_free(r);
 
3040
                return false;
 
3041
        }
 
3042
 
 
3043
        r->out.result = _netr_DsRAddressToSitenamesExW(p, r);
 
3044
 
 
3045
        if (p->rng_fault_state) {
 
3046
                talloc_free(r);
 
3047
                /* Return true here, srv_pipe_hnd.c will take care */
 
3048
                return true;
 
3049
        }
 
3050
 
 
3051
        if (DEBUGLEVEL >= 10) {
 
3052
                NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesExW, r);
 
3053
        }
 
3054
 
 
3055
        push = ndr_push_init_ctx(r, NULL);
 
3056
        if (push == NULL) {
 
3057
                talloc_free(r);
 
3058
                return false;
 
3059
        }
 
3060
 
 
3061
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3062
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3063
                talloc_free(r);
 
3064
                return false;
 
3065
        }
 
3066
 
 
3067
        blob = ndr_push_blob(push);
 
3068
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3069
                talloc_free(r);
 
3070
                return false;
 
3071
        }
 
3072
 
 
3073
        talloc_free(r);
 
3074
 
 
3075
        return true;
 
3076
}
 
3077
 
 
3078
static bool api_netr_DsrGetDcSiteCoverageW(pipes_struct *p)
 
3079
{
 
3080
        const struct ndr_interface_call *call;
 
3081
        struct ndr_pull *pull;
 
3082
        struct ndr_push *push;
 
3083
        enum ndr_err_code ndr_err;
 
3084
        DATA_BLOB blob;
 
3085
        struct netr_DsrGetDcSiteCoverageW *r;
 
3086
 
 
3087
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETDCSITECOVERAGEW];
 
3088
 
 
3089
        r = talloc(talloc_tos(), struct netr_DsrGetDcSiteCoverageW);
 
3090
        if (r == NULL) {
 
3091
                return false;
 
3092
        }
 
3093
 
 
3094
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3095
                talloc_free(r);
 
3096
                return false;
 
3097
        }
 
3098
 
 
3099
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3100
        if (pull == NULL) {
 
3101
                talloc_free(r);
 
3102
                return false;
 
3103
        }
 
3104
 
 
3105
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3106
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3107
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3108
                talloc_free(r);
 
3109
                return false;
 
3110
        }
 
3111
 
 
3112
        if (DEBUGLEVEL >= 10) {
 
3113
                NDR_PRINT_IN_DEBUG(netr_DsrGetDcSiteCoverageW, r);
 
3114
        }
 
3115
 
 
3116
        ZERO_STRUCT(r->out);
 
3117
        r->out.ctr = talloc_zero(r, struct DcSitesCtr *);
 
3118
        if (r->out.ctr == NULL) {
 
3119
                talloc_free(r);
 
3120
                return false;
 
3121
        }
 
3122
 
 
3123
        r->out.result = _netr_DsrGetDcSiteCoverageW(p, r);
 
3124
 
 
3125
        if (p->rng_fault_state) {
 
3126
                talloc_free(r);
 
3127
                /* Return true here, srv_pipe_hnd.c will take care */
 
3128
                return true;
 
3129
        }
 
3130
 
 
3131
        if (DEBUGLEVEL >= 10) {
 
3132
                NDR_PRINT_OUT_DEBUG(netr_DsrGetDcSiteCoverageW, r);
 
3133
        }
 
3134
 
 
3135
        push = ndr_push_init_ctx(r, NULL);
 
3136
        if (push == NULL) {
 
3137
                talloc_free(r);
 
3138
                return false;
 
3139
        }
 
3140
 
 
3141
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3142
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3143
                talloc_free(r);
 
3144
                return false;
 
3145
        }
 
3146
 
 
3147
        blob = ndr_push_blob(push);
 
3148
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3149
                talloc_free(r);
 
3150
                return false;
 
3151
        }
 
3152
 
 
3153
        talloc_free(r);
 
3154
 
 
3155
        return true;
 
3156
}
 
3157
 
 
3158
static bool api_netr_LogonSamLogonEx(pipes_struct *p)
 
3159
{
 
3160
        const struct ndr_interface_call *call;
 
3161
        struct ndr_pull *pull;
 
3162
        struct ndr_push *push;
 
3163
        enum ndr_err_code ndr_err;
 
3164
        DATA_BLOB blob;
 
3165
        struct netr_LogonSamLogonEx *r;
 
3166
 
 
3167
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONSAMLOGONEX];
 
3168
 
 
3169
        r = talloc(talloc_tos(), struct netr_LogonSamLogonEx);
 
3170
        if (r == NULL) {
 
3171
                return false;
 
3172
        }
 
3173
 
 
3174
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3175
                talloc_free(r);
 
3176
                return false;
 
3177
        }
 
3178
 
 
3179
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3180
        if (pull == NULL) {
 
3181
                talloc_free(r);
 
3182
                return false;
 
3183
        }
 
3184
 
 
3185
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3186
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3187
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3188
                talloc_free(r);
 
3189
                return false;
 
3190
        }
 
3191
 
 
3192
        if (DEBUGLEVEL >= 10) {
 
3193
                NDR_PRINT_IN_DEBUG(netr_LogonSamLogonEx, r);
 
3194
        }
 
3195
 
 
3196
        ZERO_STRUCT(r->out);
 
3197
        r->out.flags = r->in.flags;
 
3198
        r->out.validation = talloc_zero(r, union netr_Validation);
 
3199
        if (r->out.validation == NULL) {
 
3200
                talloc_free(r);
 
3201
                return false;
 
3202
        }
 
3203
 
 
3204
        r->out.authoritative = talloc_zero(r, uint8_t);
 
3205
        if (r->out.authoritative == NULL) {
 
3206
                talloc_free(r);
 
3207
                return false;
 
3208
        }
 
3209
 
 
3210
        r->out.result = _netr_LogonSamLogonEx(p, r);
 
3211
 
 
3212
        if (p->rng_fault_state) {
 
3213
                talloc_free(r);
 
3214
                /* Return true here, srv_pipe_hnd.c will take care */
 
3215
                return true;
 
3216
        }
 
3217
 
 
3218
        if (DEBUGLEVEL >= 10) {
 
3219
                NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx, r);
 
3220
        }
 
3221
 
 
3222
        push = ndr_push_init_ctx(r, NULL);
 
3223
        if (push == NULL) {
 
3224
                talloc_free(r);
 
3225
                return false;
 
3226
        }
 
3227
 
 
3228
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3229
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3230
                talloc_free(r);
 
3231
                return false;
 
3232
        }
 
3233
 
 
3234
        blob = ndr_push_blob(push);
 
3235
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3236
                talloc_free(r);
 
3237
                return false;
 
3238
        }
 
3239
 
 
3240
        talloc_free(r);
 
3241
 
 
3242
        return true;
 
3243
}
 
3244
 
 
3245
static bool api_netr_DsrEnumerateDomainTrusts(pipes_struct *p)
 
3246
{
 
3247
        const struct ndr_interface_call *call;
 
3248
        struct ndr_pull *pull;
 
3249
        struct ndr_push *push;
 
3250
        enum ndr_err_code ndr_err;
 
3251
        DATA_BLOB blob;
 
3252
        struct netr_DsrEnumerateDomainTrusts *r;
 
3253
 
 
3254
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRENUMERATEDOMAINTRUSTS];
 
3255
 
 
3256
        r = talloc(talloc_tos(), struct netr_DsrEnumerateDomainTrusts);
 
3257
        if (r == NULL) {
 
3258
                return false;
 
3259
        }
 
3260
 
 
3261
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3262
                talloc_free(r);
 
3263
                return false;
 
3264
        }
 
3265
 
 
3266
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3267
        if (pull == NULL) {
 
3268
                talloc_free(r);
 
3269
                return false;
 
3270
        }
 
3271
 
 
3272
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3273
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3274
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3275
                talloc_free(r);
 
3276
                return false;
 
3277
        }
 
3278
 
 
3279
        if (DEBUGLEVEL >= 10) {
 
3280
                NDR_PRINT_IN_DEBUG(netr_DsrEnumerateDomainTrusts, r);
 
3281
        }
 
3282
 
 
3283
        ZERO_STRUCT(r->out);
 
3284
        r->out.trusts = talloc_zero(r, struct netr_DomainTrustList);
 
3285
        if (r->out.trusts == NULL) {
 
3286
                talloc_free(r);
 
3287
                return false;
 
3288
        }
 
3289
 
 
3290
        r->out.result = _netr_DsrEnumerateDomainTrusts(p, r);
 
3291
 
 
3292
        if (p->rng_fault_state) {
 
3293
                talloc_free(r);
 
3294
                /* Return true here, srv_pipe_hnd.c will take care */
 
3295
                return true;
 
3296
        }
 
3297
 
 
3298
        if (DEBUGLEVEL >= 10) {
 
3299
                NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts, r);
 
3300
        }
 
3301
 
 
3302
        push = ndr_push_init_ctx(r, NULL);
 
3303
        if (push == NULL) {
 
3304
                talloc_free(r);
 
3305
                return false;
 
3306
        }
 
3307
 
 
3308
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3309
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3310
                talloc_free(r);
 
3311
                return false;
 
3312
        }
 
3313
 
 
3314
        blob = ndr_push_blob(push);
 
3315
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3316
                talloc_free(r);
 
3317
                return false;
 
3318
        }
 
3319
 
 
3320
        talloc_free(r);
 
3321
 
 
3322
        return true;
 
3323
}
 
3324
 
 
3325
static bool api_netr_DsrDeregisterDNSHostRecords(pipes_struct *p)
 
3326
{
 
3327
        const struct ndr_interface_call *call;
 
3328
        struct ndr_pull *pull;
 
3329
        struct ndr_push *push;
 
3330
        enum ndr_err_code ndr_err;
 
3331
        DATA_BLOB blob;
 
3332
        struct netr_DsrDeregisterDNSHostRecords *r;
 
3333
 
 
3334
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS];
 
3335
 
 
3336
        r = talloc(talloc_tos(), struct netr_DsrDeregisterDNSHostRecords);
 
3337
        if (r == NULL) {
 
3338
                return false;
 
3339
        }
 
3340
 
 
3341
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3342
                talloc_free(r);
 
3343
                return false;
 
3344
        }
 
3345
 
 
3346
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3347
        if (pull == NULL) {
 
3348
                talloc_free(r);
 
3349
                return false;
 
3350
        }
 
3351
 
 
3352
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3353
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3354
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3355
                talloc_free(r);
 
3356
                return false;
 
3357
        }
 
3358
 
 
3359
        if (DEBUGLEVEL >= 10) {
 
3360
                NDR_PRINT_IN_DEBUG(netr_DsrDeregisterDNSHostRecords, r);
 
3361
        }
 
3362
 
 
3363
        r->out.result = _netr_DsrDeregisterDNSHostRecords(p, r);
 
3364
 
 
3365
        if (p->rng_fault_state) {
 
3366
                talloc_free(r);
 
3367
                /* Return true here, srv_pipe_hnd.c will take care */
 
3368
                return true;
 
3369
        }
 
3370
 
 
3371
        if (DEBUGLEVEL >= 10) {
 
3372
                NDR_PRINT_OUT_DEBUG(netr_DsrDeregisterDNSHostRecords, r);
 
3373
        }
 
3374
 
 
3375
        push = ndr_push_init_ctx(r, NULL);
 
3376
        if (push == NULL) {
 
3377
                talloc_free(r);
 
3378
                return false;
 
3379
        }
 
3380
 
 
3381
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3382
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3383
                talloc_free(r);
 
3384
                return false;
 
3385
        }
 
3386
 
 
3387
        blob = ndr_push_blob(push);
 
3388
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3389
                talloc_free(r);
 
3390
                return false;
 
3391
        }
 
3392
 
 
3393
        talloc_free(r);
 
3394
 
 
3395
        return true;
 
3396
}
 
3397
 
 
3398
static bool api_netr_ServerTrustPasswordsGet(pipes_struct *p)
 
3399
{
 
3400
        const struct ndr_interface_call *call;
 
3401
        struct ndr_pull *pull;
 
3402
        struct ndr_push *push;
 
3403
        enum ndr_err_code ndr_err;
 
3404
        DATA_BLOB blob;
 
3405
        struct netr_ServerTrustPasswordsGet *r;
 
3406
 
 
3407
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERTRUSTPASSWORDSGET];
 
3408
 
 
3409
        r = talloc(talloc_tos(), struct netr_ServerTrustPasswordsGet);
 
3410
        if (r == NULL) {
 
3411
                return false;
 
3412
        }
 
3413
 
 
3414
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3415
                talloc_free(r);
 
3416
                return false;
 
3417
        }
 
3418
 
 
3419
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3420
        if (pull == NULL) {
 
3421
                talloc_free(r);
 
3422
                return false;
 
3423
        }
 
3424
 
 
3425
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3426
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3427
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3428
                talloc_free(r);
 
3429
                return false;
 
3430
        }
 
3431
 
 
3432
        if (DEBUGLEVEL >= 10) {
 
3433
                NDR_PRINT_IN_DEBUG(netr_ServerTrustPasswordsGet, r);
 
3434
        }
 
3435
 
 
3436
        ZERO_STRUCT(r->out);
 
3437
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
3438
        if (r->out.return_authenticator == NULL) {
 
3439
                talloc_free(r);
 
3440
                return false;
 
3441
        }
 
3442
 
 
3443
        r->out.password = talloc_zero(r, struct samr_Password);
 
3444
        if (r->out.password == NULL) {
 
3445
                talloc_free(r);
 
3446
                return false;
 
3447
        }
 
3448
 
 
3449
        r->out.password2 = talloc_zero(r, struct samr_Password);
 
3450
        if (r->out.password2 == NULL) {
 
3451
                talloc_free(r);
 
3452
                return false;
 
3453
        }
 
3454
 
 
3455
        r->out.result = _netr_ServerTrustPasswordsGet(p, r);
 
3456
 
 
3457
        if (p->rng_fault_state) {
 
3458
                talloc_free(r);
 
3459
                /* Return true here, srv_pipe_hnd.c will take care */
 
3460
                return true;
 
3461
        }
 
3462
 
 
3463
        if (DEBUGLEVEL >= 10) {
 
3464
                NDR_PRINT_OUT_DEBUG(netr_ServerTrustPasswordsGet, r);
 
3465
        }
 
3466
 
 
3467
        push = ndr_push_init_ctx(r, NULL);
 
3468
        if (push == NULL) {
 
3469
                talloc_free(r);
 
3470
                return false;
 
3471
        }
 
3472
 
 
3473
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3474
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3475
                talloc_free(r);
 
3476
                return false;
 
3477
        }
 
3478
 
 
3479
        blob = ndr_push_blob(push);
 
3480
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3481
                talloc_free(r);
 
3482
                return false;
 
3483
        }
 
3484
 
 
3485
        talloc_free(r);
 
3486
 
 
3487
        return true;
 
3488
}
 
3489
 
 
3490
static bool api_netr_DsRGetForestTrustInformation(pipes_struct *p)
 
3491
{
 
3492
        const struct ndr_interface_call *call;
 
3493
        struct ndr_pull *pull;
 
3494
        struct ndr_push *push;
 
3495
        enum ndr_err_code ndr_err;
 
3496
        DATA_BLOB blob;
 
3497
        struct netr_DsRGetForestTrustInformation *r;
 
3498
 
 
3499
        call = &ndr_table_netlogon.calls[NDR_NETR_DSRGETFORESTTRUSTINFORMATION];
 
3500
 
 
3501
        r = talloc(talloc_tos(), struct netr_DsRGetForestTrustInformation);
 
3502
        if (r == NULL) {
 
3503
                return false;
 
3504
        }
 
3505
 
 
3506
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3507
                talloc_free(r);
 
3508
                return false;
 
3509
        }
 
3510
 
 
3511
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3512
        if (pull == NULL) {
 
3513
                talloc_free(r);
 
3514
                return false;
 
3515
        }
 
3516
 
 
3517
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3518
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3519
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3520
                talloc_free(r);
 
3521
                return false;
 
3522
        }
 
3523
 
 
3524
        if (DEBUGLEVEL >= 10) {
 
3525
                NDR_PRINT_IN_DEBUG(netr_DsRGetForestTrustInformation, r);
 
3526
        }
 
3527
 
 
3528
        ZERO_STRUCT(r->out);
 
3529
        r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
 
3530
        if (r->out.forest_trust_info == NULL) {
 
3531
                talloc_free(r);
 
3532
                return false;
 
3533
        }
 
3534
 
 
3535
        r->out.result = _netr_DsRGetForestTrustInformation(p, r);
 
3536
 
 
3537
        if (p->rng_fault_state) {
 
3538
                talloc_free(r);
 
3539
                /* Return true here, srv_pipe_hnd.c will take care */
 
3540
                return true;
 
3541
        }
 
3542
 
 
3543
        if (DEBUGLEVEL >= 10) {
 
3544
                NDR_PRINT_OUT_DEBUG(netr_DsRGetForestTrustInformation, r);
 
3545
        }
 
3546
 
 
3547
        push = ndr_push_init_ctx(r, NULL);
 
3548
        if (push == NULL) {
 
3549
                talloc_free(r);
 
3550
                return false;
 
3551
        }
 
3552
 
 
3553
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3554
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3555
                talloc_free(r);
 
3556
                return false;
 
3557
        }
 
3558
 
 
3559
        blob = ndr_push_blob(push);
 
3560
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3561
                talloc_free(r);
 
3562
                return false;
 
3563
        }
 
3564
 
 
3565
        talloc_free(r);
 
3566
 
 
3567
        return true;
 
3568
}
 
3569
 
 
3570
static bool api_netr_GetForestTrustInformation(pipes_struct *p)
 
3571
{
 
3572
        const struct ndr_interface_call *call;
 
3573
        struct ndr_pull *pull;
 
3574
        struct ndr_push *push;
 
3575
        enum ndr_err_code ndr_err;
 
3576
        DATA_BLOB blob;
 
3577
        struct netr_GetForestTrustInformation *r;
 
3578
 
 
3579
        call = &ndr_table_netlogon.calls[NDR_NETR_GETFORESTTRUSTINFORMATION];
 
3580
 
 
3581
        r = talloc(talloc_tos(), struct netr_GetForestTrustInformation);
 
3582
        if (r == NULL) {
 
3583
                return false;
 
3584
        }
 
3585
 
 
3586
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3587
                talloc_free(r);
 
3588
                return false;
 
3589
        }
 
3590
 
 
3591
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3592
        if (pull == NULL) {
 
3593
                talloc_free(r);
 
3594
                return false;
 
3595
        }
 
3596
 
 
3597
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3598
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3599
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3600
                talloc_free(r);
 
3601
                return false;
 
3602
        }
 
3603
 
 
3604
        if (DEBUGLEVEL >= 10) {
 
3605
                NDR_PRINT_IN_DEBUG(netr_GetForestTrustInformation, r);
 
3606
        }
 
3607
 
 
3608
        ZERO_STRUCT(r->out);
 
3609
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
3610
        if (r->out.return_authenticator == NULL) {
 
3611
                talloc_free(r);
 
3612
                return false;
 
3613
        }
 
3614
 
 
3615
        r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
 
3616
        if (r->out.forest_trust_info == NULL) {
 
3617
                talloc_free(r);
 
3618
                return false;
 
3619
        }
 
3620
 
 
3621
        r->out.result = _netr_GetForestTrustInformation(p, r);
 
3622
 
 
3623
        if (p->rng_fault_state) {
 
3624
                talloc_free(r);
 
3625
                /* Return true here, srv_pipe_hnd.c will take care */
 
3626
                return true;
 
3627
        }
 
3628
 
 
3629
        if (DEBUGLEVEL >= 10) {
 
3630
                NDR_PRINT_OUT_DEBUG(netr_GetForestTrustInformation, r);
 
3631
        }
 
3632
 
 
3633
        push = ndr_push_init_ctx(r, NULL);
 
3634
        if (push == NULL) {
 
3635
                talloc_free(r);
 
3636
                return false;
 
3637
        }
 
3638
 
 
3639
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3640
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3641
                talloc_free(r);
 
3642
                return false;
 
3643
        }
 
3644
 
 
3645
        blob = ndr_push_blob(push);
 
3646
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3647
                talloc_free(r);
 
3648
                return false;
 
3649
        }
 
3650
 
 
3651
        talloc_free(r);
 
3652
 
 
3653
        return true;
 
3654
}
 
3655
 
 
3656
static bool api_netr_LogonSamLogonWithFlags(pipes_struct *p)
 
3657
{
 
3658
        const struct ndr_interface_call *call;
 
3659
        struct ndr_pull *pull;
 
3660
        struct ndr_push *push;
 
3661
        enum ndr_err_code ndr_err;
 
3662
        DATA_BLOB blob;
 
3663
        struct netr_LogonSamLogonWithFlags *r;
 
3664
 
 
3665
        call = &ndr_table_netlogon.calls[NDR_NETR_LOGONSAMLOGONWITHFLAGS];
 
3666
 
 
3667
        r = talloc(talloc_tos(), struct netr_LogonSamLogonWithFlags);
 
3668
        if (r == NULL) {
 
3669
                return false;
 
3670
        }
 
3671
 
 
3672
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3673
                talloc_free(r);
 
3674
                return false;
 
3675
        }
 
3676
 
 
3677
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3678
        if (pull == NULL) {
 
3679
                talloc_free(r);
 
3680
                return false;
 
3681
        }
 
3682
 
 
3683
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3684
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3685
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3686
                talloc_free(r);
 
3687
                return false;
 
3688
        }
 
3689
 
 
3690
        if (DEBUGLEVEL >= 10) {
 
3691
                NDR_PRINT_IN_DEBUG(netr_LogonSamLogonWithFlags, r);
 
3692
        }
 
3693
 
 
3694
        ZERO_STRUCT(r->out);
 
3695
        r->out.return_authenticator = r->in.return_authenticator;
 
3696
        r->out.flags = r->in.flags;
 
3697
        r->out.validation = talloc_zero(r, union netr_Validation);
 
3698
        if (r->out.validation == NULL) {
 
3699
                talloc_free(r);
 
3700
                return false;
 
3701
        }
 
3702
 
 
3703
        r->out.authoritative = talloc_zero(r, uint8_t);
 
3704
        if (r->out.authoritative == NULL) {
 
3705
                talloc_free(r);
 
3706
                return false;
 
3707
        }
 
3708
 
 
3709
        r->out.result = _netr_LogonSamLogonWithFlags(p, r);
 
3710
 
 
3711
        if (p->rng_fault_state) {
 
3712
                talloc_free(r);
 
3713
                /* Return true here, srv_pipe_hnd.c will take care */
 
3714
                return true;
 
3715
        }
 
3716
 
 
3717
        if (DEBUGLEVEL >= 10) {
 
3718
                NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags, r);
 
3719
        }
 
3720
 
 
3721
        push = ndr_push_init_ctx(r, NULL);
 
3722
        if (push == NULL) {
 
3723
                talloc_free(r);
 
3724
                return false;
 
3725
        }
 
3726
 
 
3727
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3728
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3729
                talloc_free(r);
 
3730
                return false;
 
3731
        }
 
3732
 
 
3733
        blob = ndr_push_blob(push);
 
3734
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3735
                talloc_free(r);
 
3736
                return false;
 
3737
        }
 
3738
 
 
3739
        talloc_free(r);
 
3740
 
 
3741
        return true;
 
3742
}
 
3743
 
 
3744
static bool api_netr_ServerGetTrustInfo(pipes_struct *p)
 
3745
{
 
3746
        const struct ndr_interface_call *call;
 
3747
        struct ndr_pull *pull;
 
3748
        struct ndr_push *push;
 
3749
        enum ndr_err_code ndr_err;
 
3750
        DATA_BLOB blob;
 
3751
        struct netr_ServerGetTrustInfo *r;
 
3752
 
 
3753
        call = &ndr_table_netlogon.calls[NDR_NETR_SERVERGETTRUSTINFO];
 
3754
 
 
3755
        r = talloc(talloc_tos(), struct netr_ServerGetTrustInfo);
 
3756
        if (r == NULL) {
 
3757
                return false;
 
3758
        }
 
3759
 
 
3760
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 
3761
                talloc_free(r);
 
3762
                return false;
 
3763
        }
 
3764
 
 
3765
        pull = ndr_pull_init_blob(&blob, r, NULL);
 
3766
        if (pull == NULL) {
 
3767
                talloc_free(r);
 
3768
                return false;
 
3769
        }
 
3770
 
 
3771
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
3772
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
3773
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3774
                talloc_free(r);
 
3775
                return false;
 
3776
        }
 
3777
 
 
3778
        if (DEBUGLEVEL >= 10) {
 
3779
                NDR_PRINT_IN_DEBUG(netr_ServerGetTrustInfo, r);
 
3780
        }
 
3781
 
 
3782
        ZERO_STRUCT(r->out);
 
3783
        r->out.return_authenticator = talloc_zero(r, struct netr_Authenticator);
 
3784
        if (r->out.return_authenticator == NULL) {
 
3785
                talloc_free(r);
 
3786
                return false;
 
3787
        }
 
3788
 
 
3789
        r->out.new_owf_password = talloc_zero(r, struct samr_Password);
 
3790
        if (r->out.new_owf_password == NULL) {
 
3791
                talloc_free(r);
 
3792
                return false;
 
3793
        }
 
3794
 
 
3795
        r->out.old_owf_password = talloc_zero(r, struct samr_Password);
 
3796
        if (r->out.old_owf_password == NULL) {
 
3797
                talloc_free(r);
 
3798
                return false;
 
3799
        }
 
3800
 
 
3801
        r->out.trust_info = talloc_zero(r, struct netr_TrustInfo *);
 
3802
        if (r->out.trust_info == NULL) {
 
3803
                talloc_free(r);
 
3804
                return false;
 
3805
        }
 
3806
 
 
3807
        r->out.result = _netr_ServerGetTrustInfo(p, r);
 
3808
 
 
3809
        if (p->rng_fault_state) {
 
3810
                talloc_free(r);
 
3811
                /* Return true here, srv_pipe_hnd.c will take care */
 
3812
                return true;
 
3813
        }
 
3814
 
 
3815
        if (DEBUGLEVEL >= 10) {
 
3816
                NDR_PRINT_OUT_DEBUG(netr_ServerGetTrustInfo, r);
 
3817
        }
 
3818
 
 
3819
        push = ndr_push_init_ctx(r, NULL);
 
3820
        if (push == NULL) {
 
3821
                talloc_free(r);
 
3822
                return false;
 
3823
        }
 
3824
 
 
3825
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
3826
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
3827
                talloc_free(r);
 
3828
                return false;
 
3829
        }
 
3830
 
 
3831
        blob = ndr_push_blob(push);
 
3832
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 
3833
                talloc_free(r);
 
3834
                return false;
 
3835
        }
 
3836
 
 
3837
        talloc_free(r);
 
3838
 
 
3839
        return true;
 
3840
}
 
3841
 
 
3842
 
 
3843
/* Tables */
 
3844
static struct api_struct api_netlogon_cmds[] = 
 
3845
{
 
3846
        {"NETR_LOGONUASLOGON", NDR_NETR_LOGONUASLOGON, api_netr_LogonUasLogon},
 
3847
        {"NETR_LOGONUASLOGOFF", NDR_NETR_LOGONUASLOGOFF, api_netr_LogonUasLogoff},
 
3848
        {"NETR_LOGONSAMLOGON", NDR_NETR_LOGONSAMLOGON, api_netr_LogonSamLogon},
 
3849
        {"NETR_LOGONSAMLOGOFF", NDR_NETR_LOGONSAMLOGOFF, api_netr_LogonSamLogoff},
 
3850
        {"NETR_SERVERREQCHALLENGE", NDR_NETR_SERVERREQCHALLENGE, api_netr_ServerReqChallenge},
 
3851
        {"NETR_SERVERAUTHENTICATE", NDR_NETR_SERVERAUTHENTICATE, api_netr_ServerAuthenticate},
 
3852
        {"NETR_SERVERPASSWORDSET", NDR_NETR_SERVERPASSWORDSET, api_netr_ServerPasswordSet},
 
3853
        {"NETR_DATABASEDELTAS", NDR_NETR_DATABASEDELTAS, api_netr_DatabaseDeltas},
 
3854
        {"NETR_DATABASESYNC", NDR_NETR_DATABASESYNC, api_netr_DatabaseSync},
 
3855
        {"NETR_ACCOUNTDELTAS", NDR_NETR_ACCOUNTDELTAS, api_netr_AccountDeltas},
 
3856
        {"NETR_ACCOUNTSYNC", NDR_NETR_ACCOUNTSYNC, api_netr_AccountSync},
 
3857
        {"NETR_GETDCNAME", NDR_NETR_GETDCNAME, api_netr_GetDcName},
 
3858
        {"NETR_LOGONCONTROL", NDR_NETR_LOGONCONTROL, api_netr_LogonControl},
 
3859
        {"NETR_GETANYDCNAME", NDR_NETR_GETANYDCNAME, api_netr_GetAnyDCName},
 
3860
        {"NETR_LOGONCONTROL2", NDR_NETR_LOGONCONTROL2, api_netr_LogonControl2},
 
3861
        {"NETR_SERVERAUTHENTICATE2", NDR_NETR_SERVERAUTHENTICATE2, api_netr_ServerAuthenticate2},
 
3862
        {"NETR_DATABASESYNC2", NDR_NETR_DATABASESYNC2, api_netr_DatabaseSync2},
 
3863
        {"NETR_DATABASEREDO", NDR_NETR_DATABASEREDO, api_netr_DatabaseRedo},
 
3864
        {"NETR_LOGONCONTROL2EX", NDR_NETR_LOGONCONTROL2EX, api_netr_LogonControl2Ex},
 
3865
        {"NETR_NETRENUMERATETRUSTEDDOMAINS", NDR_NETR_NETRENUMERATETRUSTEDDOMAINS, api_netr_NetrEnumerateTrustedDomains},
 
3866
        {"NETR_DSRGETDCNAME", NDR_NETR_DSRGETDCNAME, api_netr_DsRGetDCName},
 
3867
        {"NETR_LOGONGETCAPABILITIES", NDR_NETR_LOGONGETCAPABILITIES, api_netr_LogonGetCapabilities},
 
3868
        {"NETR_NETRLOGONSETSERVICEBITS", NDR_NETR_NETRLOGONSETSERVICEBITS, api_netr_NETRLOGONSETSERVICEBITS},
 
3869
        {"NETR_LOGONGETTRUSTRID", NDR_NETR_LOGONGETTRUSTRID, api_netr_LogonGetTrustRid},
 
3870
        {"NETR_NETRLOGONCOMPUTESERVERDIGEST", NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST, api_netr_NETRLOGONCOMPUTESERVERDIGEST},
 
3871
        {"NETR_NETRLOGONCOMPUTECLIENTDIGEST", NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST, api_netr_NETRLOGONCOMPUTECLIENTDIGEST},
 
3872
        {"NETR_SERVERAUTHENTICATE3", NDR_NETR_SERVERAUTHENTICATE3, api_netr_ServerAuthenticate3},
 
3873
        {"NETR_DSRGETDCNAMEEX", NDR_NETR_DSRGETDCNAMEEX, api_netr_DsRGetDCNameEx},
 
3874
        {"NETR_DSRGETSITENAME", NDR_NETR_DSRGETSITENAME, api_netr_DsRGetSiteName},
 
3875
        {"NETR_LOGONGETDOMAININFO", NDR_NETR_LOGONGETDOMAININFO, api_netr_LogonGetDomainInfo},
 
3876
        {"NETR_SERVERPASSWORDSET2", NDR_NETR_SERVERPASSWORDSET2, api_netr_ServerPasswordSet2},
 
3877
        {"NETR_SERVERPASSWORDGET", NDR_NETR_SERVERPASSWORDGET, api_netr_ServerPasswordGet},
 
3878
        {"NETR_NETRLOGONSENDTOSAM", NDR_NETR_NETRLOGONSENDTOSAM, api_netr_NETRLOGONSENDTOSAM},
 
3879
        {"NETR_DSRADDRESSTOSITENAMESW", NDR_NETR_DSRADDRESSTOSITENAMESW, api_netr_DsRAddressToSitenamesW},
 
3880
        {"NETR_DSRGETDCNAMEEX2", NDR_NETR_DSRGETDCNAMEEX2, api_netr_DsRGetDCNameEx2},
 
3881
        {"NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN", NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN, api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN},
 
3882
        {"NETR_NETRENUMERATETRUSTEDDOMAINSEX", NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX, api_netr_NetrEnumerateTrustedDomainsEx},
 
3883
        {"NETR_DSRADDRESSTOSITENAMESEXW", NDR_NETR_DSRADDRESSTOSITENAMESEXW, api_netr_DsRAddressToSitenamesExW},
 
3884
        {"NETR_DSRGETDCSITECOVERAGEW", NDR_NETR_DSRGETDCSITECOVERAGEW, api_netr_DsrGetDcSiteCoverageW},
 
3885
        {"NETR_LOGONSAMLOGONEX", NDR_NETR_LOGONSAMLOGONEX, api_netr_LogonSamLogonEx},
 
3886
        {"NETR_DSRENUMERATEDOMAINTRUSTS", NDR_NETR_DSRENUMERATEDOMAINTRUSTS, api_netr_DsrEnumerateDomainTrusts},
 
3887
        {"NETR_DSRDEREGISTERDNSHOSTRECORDS", NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS, api_netr_DsrDeregisterDNSHostRecords},
 
3888
        {"NETR_SERVERTRUSTPASSWORDSGET", NDR_NETR_SERVERTRUSTPASSWORDSGET, api_netr_ServerTrustPasswordsGet},
 
3889
        {"NETR_DSRGETFORESTTRUSTINFORMATION", NDR_NETR_DSRGETFORESTTRUSTINFORMATION, api_netr_DsRGetForestTrustInformation},
 
3890
        {"NETR_GETFORESTTRUSTINFORMATION", NDR_NETR_GETFORESTTRUSTINFORMATION, api_netr_GetForestTrustInformation},
 
3891
        {"NETR_LOGONSAMLOGONWITHFLAGS", NDR_NETR_LOGONSAMLOGONWITHFLAGS, api_netr_LogonSamLogonWithFlags},
 
3892
        {"NETR_SERVERGETTRUSTINFO", NDR_NETR_SERVERGETTRUSTINFO, api_netr_ServerGetTrustInfo},
 
3893
};
 
3894
 
 
3895
void netlogon_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
3896
{
 
3897
        *fns = api_netlogon_cmds;
 
3898
        *n_fns = sizeof(api_netlogon_cmds) / sizeof(struct api_struct);
 
3899
}
 
3900
 
 
3901
NTSTATUS rpc_netlogon_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
 
3902
{
 
3903
        if (cli->pipes_struct == NULL) {
 
3904
                return NT_STATUS_INVALID_PARAMETER;
 
3905
        }
 
3906
 
 
3907
        switch (opnum)
 
3908
        {
 
3909
                case NDR_NETR_LOGONUASLOGON: {
 
3910
                        struct netr_LogonUasLogon *r = (struct netr_LogonUasLogon *)_r;
 
3911
                        ZERO_STRUCT(r->out);
 
3912
                        r->out.info = talloc_zero(mem_ctx, struct netr_UasInfo *);
 
3913
                        if (r->out.info == NULL) {
 
3914
                        return NT_STATUS_NO_MEMORY;
 
3915
                        }
 
3916
 
 
3917
                        r->out.result = _netr_LogonUasLogon(cli->pipes_struct, r);
 
3918
                        return NT_STATUS_OK;
 
3919
                }
 
3920
 
 
3921
                case NDR_NETR_LOGONUASLOGOFF: {
 
3922
                        struct netr_LogonUasLogoff *r = (struct netr_LogonUasLogoff *)_r;
 
3923
                        ZERO_STRUCT(r->out);
 
3924
                        r->out.info = talloc_zero(mem_ctx, struct netr_UasLogoffInfo);
 
3925
                        if (r->out.info == NULL) {
 
3926
                        return NT_STATUS_NO_MEMORY;
 
3927
                        }
 
3928
 
 
3929
                        r->out.result = _netr_LogonUasLogoff(cli->pipes_struct, r);
 
3930
                        return NT_STATUS_OK;
 
3931
                }
 
3932
 
 
3933
                case NDR_NETR_LOGONSAMLOGON: {
 
3934
                        struct netr_LogonSamLogon *r = (struct netr_LogonSamLogon *)_r;
 
3935
                        ZERO_STRUCT(r->out);
 
3936
                        r->out.return_authenticator = r->in.return_authenticator;
 
3937
                        r->out.validation = talloc_zero(mem_ctx, union netr_Validation);
 
3938
                        if (r->out.validation == NULL) {
 
3939
                        return NT_STATUS_NO_MEMORY;
 
3940
                        }
 
3941
 
 
3942
                        r->out.authoritative = talloc_zero(mem_ctx, uint8_t);
 
3943
                        if (r->out.authoritative == NULL) {
 
3944
                        return NT_STATUS_NO_MEMORY;
 
3945
                        }
 
3946
 
 
3947
                        r->out.result = _netr_LogonSamLogon(cli->pipes_struct, r);
 
3948
                        return NT_STATUS_OK;
 
3949
                }
 
3950
 
 
3951
                case NDR_NETR_LOGONSAMLOGOFF: {
 
3952
                        struct netr_LogonSamLogoff *r = (struct netr_LogonSamLogoff *)_r;
 
3953
                        ZERO_STRUCT(r->out);
 
3954
                        r->out.return_authenticator = r->in.return_authenticator;
 
3955
                        r->out.result = _netr_LogonSamLogoff(cli->pipes_struct, r);
 
3956
                        return NT_STATUS_OK;
 
3957
                }
 
3958
 
 
3959
                case NDR_NETR_SERVERREQCHALLENGE: {
 
3960
                        struct netr_ServerReqChallenge *r = (struct netr_ServerReqChallenge *)_r;
 
3961
                        ZERO_STRUCT(r->out);
 
3962
                        r->out.return_credentials = talloc_zero(mem_ctx, struct netr_Credential);
 
3963
                        if (r->out.return_credentials == NULL) {
 
3964
                        return NT_STATUS_NO_MEMORY;
 
3965
                        }
 
3966
 
 
3967
                        r->out.result = _netr_ServerReqChallenge(cli->pipes_struct, r);
 
3968
                        return NT_STATUS_OK;
 
3969
                }
 
3970
 
 
3971
                case NDR_NETR_SERVERAUTHENTICATE: {
 
3972
                        struct netr_ServerAuthenticate *r = (struct netr_ServerAuthenticate *)_r;
 
3973
                        ZERO_STRUCT(r->out);
 
3974
                        r->out.return_credentials = talloc_zero(mem_ctx, struct netr_Credential);
 
3975
                        if (r->out.return_credentials == NULL) {
 
3976
                        return NT_STATUS_NO_MEMORY;
 
3977
                        }
 
3978
 
 
3979
                        r->out.result = _netr_ServerAuthenticate(cli->pipes_struct, r);
 
3980
                        return NT_STATUS_OK;
 
3981
                }
 
3982
 
 
3983
                case NDR_NETR_SERVERPASSWORDSET: {
 
3984
                        struct netr_ServerPasswordSet *r = (struct netr_ServerPasswordSet *)_r;
 
3985
                        ZERO_STRUCT(r->out);
 
3986
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
3987
                        if (r->out.return_authenticator == NULL) {
 
3988
                        return NT_STATUS_NO_MEMORY;
 
3989
                        }
 
3990
 
 
3991
                        r->out.result = _netr_ServerPasswordSet(cli->pipes_struct, r);
 
3992
                        return NT_STATUS_OK;
 
3993
                }
 
3994
 
 
3995
                case NDR_NETR_DATABASEDELTAS: {
 
3996
                        struct netr_DatabaseDeltas *r = (struct netr_DatabaseDeltas *)_r;
 
3997
                        ZERO_STRUCT(r->out);
 
3998
                        r->out.return_authenticator = r->in.return_authenticator;
 
3999
                        r->out.sequence_num = r->in.sequence_num;
 
4000
                        r->out.delta_enum_array = talloc_zero(mem_ctx, struct netr_DELTA_ENUM_ARRAY *);
 
4001
                        if (r->out.delta_enum_array == NULL) {
 
4002
                        return NT_STATUS_NO_MEMORY;
 
4003
                        }
 
4004
 
 
4005
                        r->out.result = _netr_DatabaseDeltas(cli->pipes_struct, r);
 
4006
                        return NT_STATUS_OK;
 
4007
                }
 
4008
 
 
4009
                case NDR_NETR_DATABASESYNC: {
 
4010
                        struct netr_DatabaseSync *r = (struct netr_DatabaseSync *)_r;
 
4011
                        ZERO_STRUCT(r->out);
 
4012
                        r->out.return_authenticator = r->in.return_authenticator;
 
4013
                        r->out.sync_context = r->in.sync_context;
 
4014
                        r->out.delta_enum_array = talloc_zero(mem_ctx, struct netr_DELTA_ENUM_ARRAY *);
 
4015
                        if (r->out.delta_enum_array == NULL) {
 
4016
                        return NT_STATUS_NO_MEMORY;
 
4017
                        }
 
4018
 
 
4019
                        r->out.result = _netr_DatabaseSync(cli->pipes_struct, r);
 
4020
                        return NT_STATUS_OK;
 
4021
                }
 
4022
 
 
4023
                case NDR_NETR_ACCOUNTDELTAS: {
 
4024
                        struct netr_AccountDeltas *r = (struct netr_AccountDeltas *)_r;
 
4025
                        ZERO_STRUCT(r->out);
 
4026
                        r->out.return_authenticator = r->in.return_authenticator;
 
4027
                        r->out.buffer = talloc_zero(mem_ctx, struct netr_AccountBuffer);
 
4028
                        if (r->out.buffer == NULL) {
 
4029
                        return NT_STATUS_NO_MEMORY;
 
4030
                        }
 
4031
 
 
4032
                        r->out.count_returned = talloc_zero(mem_ctx, uint32_t);
 
4033
                        if (r->out.count_returned == NULL) {
 
4034
                        return NT_STATUS_NO_MEMORY;
 
4035
                        }
 
4036
 
 
4037
                        r->out.total_entries = talloc_zero(mem_ctx, uint32_t);
 
4038
                        if (r->out.total_entries == NULL) {
 
4039
                        return NT_STATUS_NO_MEMORY;
 
4040
                        }
 
4041
 
 
4042
                        r->out.recordid = talloc_zero(mem_ctx, struct netr_UAS_INFO_0);
 
4043
                        if (r->out.recordid == NULL) {
 
4044
                        return NT_STATUS_NO_MEMORY;
 
4045
                        }
 
4046
 
 
4047
                        r->out.result = _netr_AccountDeltas(cli->pipes_struct, r);
 
4048
                        return NT_STATUS_OK;
 
4049
                }
 
4050
 
 
4051
                case NDR_NETR_ACCOUNTSYNC: {
 
4052
                        struct netr_AccountSync *r = (struct netr_AccountSync *)_r;
 
4053
                        ZERO_STRUCT(r->out);
 
4054
                        r->out.return_authenticator = r->in.return_authenticator;
 
4055
                        r->out.recordid = r->in.recordid;
 
4056
                        r->out.buffer = talloc_zero(mem_ctx, struct netr_AccountBuffer);
 
4057
                        if (r->out.buffer == NULL) {
 
4058
                        return NT_STATUS_NO_MEMORY;
 
4059
                        }
 
4060
 
 
4061
                        r->out.count_returned = talloc_zero(mem_ctx, uint32_t);
 
4062
                        if (r->out.count_returned == NULL) {
 
4063
                        return NT_STATUS_NO_MEMORY;
 
4064
                        }
 
4065
 
 
4066
                        r->out.total_entries = talloc_zero(mem_ctx, uint32_t);
 
4067
                        if (r->out.total_entries == NULL) {
 
4068
                        return NT_STATUS_NO_MEMORY;
 
4069
                        }
 
4070
 
 
4071
                        r->out.next_reference = talloc_zero(mem_ctx, uint32_t);
 
4072
                        if (r->out.next_reference == NULL) {
 
4073
                        return NT_STATUS_NO_MEMORY;
 
4074
                        }
 
4075
 
 
4076
                        r->out.result = _netr_AccountSync(cli->pipes_struct, r);
 
4077
                        return NT_STATUS_OK;
 
4078
                }
 
4079
 
 
4080
                case NDR_NETR_GETDCNAME: {
 
4081
                        struct netr_GetDcName *r = (struct netr_GetDcName *)_r;
 
4082
                        ZERO_STRUCT(r->out);
 
4083
                        r->out.dcname = talloc_zero(mem_ctx, const char *);
 
4084
                        if (r->out.dcname == NULL) {
 
4085
                        return NT_STATUS_NO_MEMORY;
 
4086
                        }
 
4087
 
 
4088
                        r->out.result = _netr_GetDcName(cli->pipes_struct, r);
 
4089
                        return NT_STATUS_OK;
 
4090
                }
 
4091
 
 
4092
                case NDR_NETR_LOGONCONTROL: {
 
4093
                        struct netr_LogonControl *r = (struct netr_LogonControl *)_r;
 
4094
                        ZERO_STRUCT(r->out);
 
4095
                        r->out.info = talloc_zero(mem_ctx, union netr_CONTROL_QUERY_INFORMATION);
 
4096
                        if (r->out.info == NULL) {
 
4097
                        return NT_STATUS_NO_MEMORY;
 
4098
                        }
 
4099
 
 
4100
                        r->out.result = _netr_LogonControl(cli->pipes_struct, r);
 
4101
                        return NT_STATUS_OK;
 
4102
                }
 
4103
 
 
4104
                case NDR_NETR_GETANYDCNAME: {
 
4105
                        struct netr_GetAnyDCName *r = (struct netr_GetAnyDCName *)_r;
 
4106
                        ZERO_STRUCT(r->out);
 
4107
                        r->out.dcname = talloc_zero(mem_ctx, const char *);
 
4108
                        if (r->out.dcname == NULL) {
 
4109
                        return NT_STATUS_NO_MEMORY;
 
4110
                        }
 
4111
 
 
4112
                        r->out.result = _netr_GetAnyDCName(cli->pipes_struct, r);
 
4113
                        return NT_STATUS_OK;
 
4114
                }
 
4115
 
 
4116
                case NDR_NETR_LOGONCONTROL2: {
 
4117
                        struct netr_LogonControl2 *r = (struct netr_LogonControl2 *)_r;
 
4118
                        ZERO_STRUCT(r->out);
 
4119
                        r->out.query = talloc_zero(mem_ctx, union netr_CONTROL_QUERY_INFORMATION);
 
4120
                        if (r->out.query == NULL) {
 
4121
                        return NT_STATUS_NO_MEMORY;
 
4122
                        }
 
4123
 
 
4124
                        r->out.result = _netr_LogonControl2(cli->pipes_struct, r);
 
4125
                        return NT_STATUS_OK;
 
4126
                }
 
4127
 
 
4128
                case NDR_NETR_SERVERAUTHENTICATE2: {
 
4129
                        struct netr_ServerAuthenticate2 *r = (struct netr_ServerAuthenticate2 *)_r;
 
4130
                        ZERO_STRUCT(r->out);
 
4131
                        r->out.negotiate_flags = r->in.negotiate_flags;
 
4132
                        r->out.return_credentials = talloc_zero(mem_ctx, struct netr_Credential);
 
4133
                        if (r->out.return_credentials == NULL) {
 
4134
                        return NT_STATUS_NO_MEMORY;
 
4135
                        }
 
4136
 
 
4137
                        r->out.result = _netr_ServerAuthenticate2(cli->pipes_struct, r);
 
4138
                        return NT_STATUS_OK;
 
4139
                }
 
4140
 
 
4141
                case NDR_NETR_DATABASESYNC2: {
 
4142
                        struct netr_DatabaseSync2 *r = (struct netr_DatabaseSync2 *)_r;
 
4143
                        ZERO_STRUCT(r->out);
 
4144
                        r->out.return_authenticator = r->in.return_authenticator;
 
4145
                        r->out.sync_context = r->in.sync_context;
 
4146
                        r->out.delta_enum_array = talloc_zero(mem_ctx, struct netr_DELTA_ENUM_ARRAY *);
 
4147
                        if (r->out.delta_enum_array == NULL) {
 
4148
                        return NT_STATUS_NO_MEMORY;
 
4149
                        }
 
4150
 
 
4151
                        r->out.result = _netr_DatabaseSync2(cli->pipes_struct, r);
 
4152
                        return NT_STATUS_OK;
 
4153
                }
 
4154
 
 
4155
                case NDR_NETR_DATABASEREDO: {
 
4156
                        struct netr_DatabaseRedo *r = (struct netr_DatabaseRedo *)_r;
 
4157
                        ZERO_STRUCT(r->out);
 
4158
                        r->out.return_authenticator = r->in.return_authenticator;
 
4159
                        r->out.delta_enum_array = talloc_zero(mem_ctx, struct netr_DELTA_ENUM_ARRAY *);
 
4160
                        if (r->out.delta_enum_array == NULL) {
 
4161
                        return NT_STATUS_NO_MEMORY;
 
4162
                        }
 
4163
 
 
4164
                        r->out.result = _netr_DatabaseRedo(cli->pipes_struct, r);
 
4165
                        return NT_STATUS_OK;
 
4166
                }
 
4167
 
 
4168
                case NDR_NETR_LOGONCONTROL2EX: {
 
4169
                        struct netr_LogonControl2Ex *r = (struct netr_LogonControl2Ex *)_r;
 
4170
                        ZERO_STRUCT(r->out);
 
4171
                        r->out.query = talloc_zero(mem_ctx, union netr_CONTROL_QUERY_INFORMATION);
 
4172
                        if (r->out.query == NULL) {
 
4173
                        return NT_STATUS_NO_MEMORY;
 
4174
                        }
 
4175
 
 
4176
                        r->out.result = _netr_LogonControl2Ex(cli->pipes_struct, r);
 
4177
                        return NT_STATUS_OK;
 
4178
                }
 
4179
 
 
4180
                case NDR_NETR_NETRENUMERATETRUSTEDDOMAINS: {
 
4181
                        struct netr_NetrEnumerateTrustedDomains *r = (struct netr_NetrEnumerateTrustedDomains *)_r;
 
4182
                        ZERO_STRUCT(r->out);
 
4183
                        r->out.trusted_domains_blob = talloc_zero(mem_ctx, struct netr_Blob);
 
4184
                        if (r->out.trusted_domains_blob == NULL) {
 
4185
                        return NT_STATUS_NO_MEMORY;
 
4186
                        }
 
4187
 
 
4188
                        r->out.result = _netr_NetrEnumerateTrustedDomains(cli->pipes_struct, r);
 
4189
                        return NT_STATUS_OK;
 
4190
                }
 
4191
 
 
4192
                case NDR_NETR_DSRGETDCNAME: {
 
4193
                        struct netr_DsRGetDCName *r = (struct netr_DsRGetDCName *)_r;
 
4194
                        ZERO_STRUCT(r->out);
 
4195
                        r->out.info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo *);
 
4196
                        if (r->out.info == NULL) {
 
4197
                        return NT_STATUS_NO_MEMORY;
 
4198
                        }
 
4199
 
 
4200
                        r->out.result = _netr_DsRGetDCName(cli->pipes_struct, r);
 
4201
                        return NT_STATUS_OK;
 
4202
                }
 
4203
 
 
4204
                case NDR_NETR_LOGONGETCAPABILITIES: {
 
4205
                        struct netr_LogonGetCapabilities *r = (struct netr_LogonGetCapabilities *)_r;
 
4206
                        ZERO_STRUCT(r->out);
 
4207
                        r->out.return_authenticator = r->in.return_authenticator;
 
4208
                        r->out.capabilities = talloc_zero(mem_ctx, union netr_Capabilities);
 
4209
                        if (r->out.capabilities == NULL) {
 
4210
                        return NT_STATUS_NO_MEMORY;
 
4211
                        }
 
4212
 
 
4213
                        r->out.result = _netr_LogonGetCapabilities(cli->pipes_struct, r);
 
4214
                        return NT_STATUS_OK;
 
4215
                }
 
4216
 
 
4217
                case NDR_NETR_NETRLOGONSETSERVICEBITS: {
 
4218
                        struct netr_NETRLOGONSETSERVICEBITS *r = (struct netr_NETRLOGONSETSERVICEBITS *)_r;
 
4219
                        r->out.result = _netr_NETRLOGONSETSERVICEBITS(cli->pipes_struct, r);
 
4220
                        return NT_STATUS_OK;
 
4221
                }
 
4222
 
 
4223
                case NDR_NETR_LOGONGETTRUSTRID: {
 
4224
                        struct netr_LogonGetTrustRid *r = (struct netr_LogonGetTrustRid *)_r;
 
4225
                        ZERO_STRUCT(r->out);
 
4226
                        r->out.rid = talloc_zero(mem_ctx, uint32_t);
 
4227
                        if (r->out.rid == NULL) {
 
4228
                        return NT_STATUS_NO_MEMORY;
 
4229
                        }
 
4230
 
 
4231
                        r->out.result = _netr_LogonGetTrustRid(cli->pipes_struct, r);
 
4232
                        return NT_STATUS_OK;
 
4233
                }
 
4234
 
 
4235
                case NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST: {
 
4236
                        struct netr_NETRLOGONCOMPUTESERVERDIGEST *r = (struct netr_NETRLOGONCOMPUTESERVERDIGEST *)_r;
 
4237
                        r->out.result = _netr_NETRLOGONCOMPUTESERVERDIGEST(cli->pipes_struct, r);
 
4238
                        return NT_STATUS_OK;
 
4239
                }
 
4240
 
 
4241
                case NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST: {
 
4242
                        struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r = (struct netr_NETRLOGONCOMPUTECLIENTDIGEST *)_r;
 
4243
                        r->out.result = _netr_NETRLOGONCOMPUTECLIENTDIGEST(cli->pipes_struct, r);
 
4244
                        return NT_STATUS_OK;
 
4245
                }
 
4246
 
 
4247
                case NDR_NETR_SERVERAUTHENTICATE3: {
 
4248
                        struct netr_ServerAuthenticate3 *r = (struct netr_ServerAuthenticate3 *)_r;
 
4249
                        ZERO_STRUCT(r->out);
 
4250
                        r->out.negotiate_flags = r->in.negotiate_flags;
 
4251
                        r->out.return_credentials = talloc_zero(mem_ctx, struct netr_Credential);
 
4252
                        if (r->out.return_credentials == NULL) {
 
4253
                        return NT_STATUS_NO_MEMORY;
 
4254
                        }
 
4255
 
 
4256
                        r->out.rid = talloc_zero(mem_ctx, uint32_t);
 
4257
                        if (r->out.rid == NULL) {
 
4258
                        return NT_STATUS_NO_MEMORY;
 
4259
                        }
 
4260
 
 
4261
                        r->out.result = _netr_ServerAuthenticate3(cli->pipes_struct, r);
 
4262
                        return NT_STATUS_OK;
 
4263
                }
 
4264
 
 
4265
                case NDR_NETR_DSRGETDCNAMEEX: {
 
4266
                        struct netr_DsRGetDCNameEx *r = (struct netr_DsRGetDCNameEx *)_r;
 
4267
                        ZERO_STRUCT(r->out);
 
4268
                        r->out.info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo *);
 
4269
                        if (r->out.info == NULL) {
 
4270
                        return NT_STATUS_NO_MEMORY;
 
4271
                        }
 
4272
 
 
4273
                        r->out.result = _netr_DsRGetDCNameEx(cli->pipes_struct, r);
 
4274
                        return NT_STATUS_OK;
 
4275
                }
 
4276
 
 
4277
                case NDR_NETR_DSRGETSITENAME: {
 
4278
                        struct netr_DsRGetSiteName *r = (struct netr_DsRGetSiteName *)_r;
 
4279
                        ZERO_STRUCT(r->out);
 
4280
                        r->out.site = talloc_zero(mem_ctx, const char *);
 
4281
                        if (r->out.site == NULL) {
 
4282
                        return NT_STATUS_NO_MEMORY;
 
4283
                        }
 
4284
 
 
4285
                        r->out.result = _netr_DsRGetSiteName(cli->pipes_struct, r);
 
4286
                        return NT_STATUS_OK;
 
4287
                }
 
4288
 
 
4289
                case NDR_NETR_LOGONGETDOMAININFO: {
 
4290
                        struct netr_LogonGetDomainInfo *r = (struct netr_LogonGetDomainInfo *)_r;
 
4291
                        ZERO_STRUCT(r->out);
 
4292
                        r->out.return_authenticator = r->in.return_authenticator;
 
4293
                        r->out.info = talloc_zero(mem_ctx, union netr_DomainInfo);
 
4294
                        if (r->out.info == NULL) {
 
4295
                        return NT_STATUS_NO_MEMORY;
 
4296
                        }
 
4297
 
 
4298
                        r->out.result = _netr_LogonGetDomainInfo(cli->pipes_struct, r);
 
4299
                        return NT_STATUS_OK;
 
4300
                }
 
4301
 
 
4302
                case NDR_NETR_SERVERPASSWORDSET2: {
 
4303
                        struct netr_ServerPasswordSet2 *r = (struct netr_ServerPasswordSet2 *)_r;
 
4304
                        ZERO_STRUCT(r->out);
 
4305
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
4306
                        if (r->out.return_authenticator == NULL) {
 
4307
                        return NT_STATUS_NO_MEMORY;
 
4308
                        }
 
4309
 
 
4310
                        r->out.result = _netr_ServerPasswordSet2(cli->pipes_struct, r);
 
4311
                        return NT_STATUS_OK;
 
4312
                }
 
4313
 
 
4314
                case NDR_NETR_SERVERPASSWORDGET: {
 
4315
                        struct netr_ServerPasswordGet *r = (struct netr_ServerPasswordGet *)_r;
 
4316
                        ZERO_STRUCT(r->out);
 
4317
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
4318
                        if (r->out.return_authenticator == NULL) {
 
4319
                        return NT_STATUS_NO_MEMORY;
 
4320
                        }
 
4321
 
 
4322
                        r->out.password = talloc_zero(mem_ctx, struct samr_Password);
 
4323
                        if (r->out.password == NULL) {
 
4324
                        return NT_STATUS_NO_MEMORY;
 
4325
                        }
 
4326
 
 
4327
                        r->out.result = _netr_ServerPasswordGet(cli->pipes_struct, r);
 
4328
                        return NT_STATUS_OK;
 
4329
                }
 
4330
 
 
4331
                case NDR_NETR_NETRLOGONSENDTOSAM: {
 
4332
                        struct netr_NETRLOGONSENDTOSAM *r = (struct netr_NETRLOGONSENDTOSAM *)_r;
 
4333
                        r->out.result = _netr_NETRLOGONSENDTOSAM(cli->pipes_struct, r);
 
4334
                        return NT_STATUS_OK;
 
4335
                }
 
4336
 
 
4337
                case NDR_NETR_DSRADDRESSTOSITENAMESW: {
 
4338
                        struct netr_DsRAddressToSitenamesW *r = (struct netr_DsRAddressToSitenamesW *)_r;
 
4339
                        ZERO_STRUCT(r->out);
 
4340
                        r->out.ctr = talloc_zero(mem_ctx, struct netr_DsRAddressToSitenamesWCtr *);
 
4341
                        if (r->out.ctr == NULL) {
 
4342
                        return NT_STATUS_NO_MEMORY;
 
4343
                        }
 
4344
 
 
4345
                        r->out.result = _netr_DsRAddressToSitenamesW(cli->pipes_struct, r);
 
4346
                        return NT_STATUS_OK;
 
4347
                }
 
4348
 
 
4349
                case NDR_NETR_DSRGETDCNAMEEX2: {
 
4350
                        struct netr_DsRGetDCNameEx2 *r = (struct netr_DsRGetDCNameEx2 *)_r;
 
4351
                        ZERO_STRUCT(r->out);
 
4352
                        r->out.info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo *);
 
4353
                        if (r->out.info == NULL) {
 
4354
                        return NT_STATUS_NO_MEMORY;
 
4355
                        }
 
4356
 
 
4357
                        r->out.result = _netr_DsRGetDCNameEx2(cli->pipes_struct, r);
 
4358
                        return NT_STATUS_OK;
 
4359
                }
 
4360
 
 
4361
                case NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN: {
 
4362
                        struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r = (struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *)_r;
 
4363
                        r->out.result = _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(cli->pipes_struct, r);
 
4364
                        return NT_STATUS_OK;
 
4365
                }
 
4366
 
 
4367
                case NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX: {
 
4368
                        struct netr_NetrEnumerateTrustedDomainsEx *r = (struct netr_NetrEnumerateTrustedDomainsEx *)_r;
 
4369
                        ZERO_STRUCT(r->out);
 
4370
                        r->out.dom_trust_list = talloc_zero(mem_ctx, struct netr_DomainTrustList);
 
4371
                        if (r->out.dom_trust_list == NULL) {
 
4372
                        return NT_STATUS_NO_MEMORY;
 
4373
                        }
 
4374
 
 
4375
                        r->out.result = _netr_NetrEnumerateTrustedDomainsEx(cli->pipes_struct, r);
 
4376
                        return NT_STATUS_OK;
 
4377
                }
 
4378
 
 
4379
                case NDR_NETR_DSRADDRESSTOSITENAMESEXW: {
 
4380
                        struct netr_DsRAddressToSitenamesExW *r = (struct netr_DsRAddressToSitenamesExW *)_r;
 
4381
                        ZERO_STRUCT(r->out);
 
4382
                        r->out.ctr = talloc_zero(mem_ctx, struct netr_DsRAddressToSitenamesExWCtr *);
 
4383
                        if (r->out.ctr == NULL) {
 
4384
                        return NT_STATUS_NO_MEMORY;
 
4385
                        }
 
4386
 
 
4387
                        r->out.result = _netr_DsRAddressToSitenamesExW(cli->pipes_struct, r);
 
4388
                        return NT_STATUS_OK;
 
4389
                }
 
4390
 
 
4391
                case NDR_NETR_DSRGETDCSITECOVERAGEW: {
 
4392
                        struct netr_DsrGetDcSiteCoverageW *r = (struct netr_DsrGetDcSiteCoverageW *)_r;
 
4393
                        ZERO_STRUCT(r->out);
 
4394
                        r->out.ctr = talloc_zero(mem_ctx, struct DcSitesCtr *);
 
4395
                        if (r->out.ctr == NULL) {
 
4396
                        return NT_STATUS_NO_MEMORY;
 
4397
                        }
 
4398
 
 
4399
                        r->out.result = _netr_DsrGetDcSiteCoverageW(cli->pipes_struct, r);
 
4400
                        return NT_STATUS_OK;
 
4401
                }
 
4402
 
 
4403
                case NDR_NETR_LOGONSAMLOGONEX: {
 
4404
                        struct netr_LogonSamLogonEx *r = (struct netr_LogonSamLogonEx *)_r;
 
4405
                        ZERO_STRUCT(r->out);
 
4406
                        r->out.flags = r->in.flags;
 
4407
                        r->out.validation = talloc_zero(mem_ctx, union netr_Validation);
 
4408
                        if (r->out.validation == NULL) {
 
4409
                        return NT_STATUS_NO_MEMORY;
 
4410
                        }
 
4411
 
 
4412
                        r->out.authoritative = talloc_zero(mem_ctx, uint8_t);
 
4413
                        if (r->out.authoritative == NULL) {
 
4414
                        return NT_STATUS_NO_MEMORY;
 
4415
                        }
 
4416
 
 
4417
                        r->out.result = _netr_LogonSamLogonEx(cli->pipes_struct, r);
 
4418
                        return NT_STATUS_OK;
 
4419
                }
 
4420
 
 
4421
                case NDR_NETR_DSRENUMERATEDOMAINTRUSTS: {
 
4422
                        struct netr_DsrEnumerateDomainTrusts *r = (struct netr_DsrEnumerateDomainTrusts *)_r;
 
4423
                        ZERO_STRUCT(r->out);
 
4424
                        r->out.trusts = talloc_zero(mem_ctx, struct netr_DomainTrustList);
 
4425
                        if (r->out.trusts == NULL) {
 
4426
                        return NT_STATUS_NO_MEMORY;
 
4427
                        }
 
4428
 
 
4429
                        r->out.result = _netr_DsrEnumerateDomainTrusts(cli->pipes_struct, r);
 
4430
                        return NT_STATUS_OK;
 
4431
                }
 
4432
 
 
4433
                case NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS: {
 
4434
                        struct netr_DsrDeregisterDNSHostRecords *r = (struct netr_DsrDeregisterDNSHostRecords *)_r;
 
4435
                        r->out.result = _netr_DsrDeregisterDNSHostRecords(cli->pipes_struct, r);
 
4436
                        return NT_STATUS_OK;
 
4437
                }
 
4438
 
 
4439
                case NDR_NETR_SERVERTRUSTPASSWORDSGET: {
 
4440
                        struct netr_ServerTrustPasswordsGet *r = (struct netr_ServerTrustPasswordsGet *)_r;
 
4441
                        ZERO_STRUCT(r->out);
 
4442
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
4443
                        if (r->out.return_authenticator == NULL) {
 
4444
                        return NT_STATUS_NO_MEMORY;
 
4445
                        }
 
4446
 
 
4447
                        r->out.password = talloc_zero(mem_ctx, struct samr_Password);
 
4448
                        if (r->out.password == NULL) {
 
4449
                        return NT_STATUS_NO_MEMORY;
 
4450
                        }
 
4451
 
 
4452
                        r->out.password2 = talloc_zero(mem_ctx, struct samr_Password);
 
4453
                        if (r->out.password2 == NULL) {
 
4454
                        return NT_STATUS_NO_MEMORY;
 
4455
                        }
 
4456
 
 
4457
                        r->out.result = _netr_ServerTrustPasswordsGet(cli->pipes_struct, r);
 
4458
                        return NT_STATUS_OK;
 
4459
                }
 
4460
 
 
4461
                case NDR_NETR_DSRGETFORESTTRUSTINFORMATION: {
 
4462
                        struct netr_DsRGetForestTrustInformation *r = (struct netr_DsRGetForestTrustInformation *)_r;
 
4463
                        ZERO_STRUCT(r->out);
 
4464
                        r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
 
4465
                        if (r->out.forest_trust_info == NULL) {
 
4466
                        return NT_STATUS_NO_MEMORY;
 
4467
                        }
 
4468
 
 
4469
                        r->out.result = _netr_DsRGetForestTrustInformation(cli->pipes_struct, r);
 
4470
                        return NT_STATUS_OK;
 
4471
                }
 
4472
 
 
4473
                case NDR_NETR_GETFORESTTRUSTINFORMATION: {
 
4474
                        struct netr_GetForestTrustInformation *r = (struct netr_GetForestTrustInformation *)_r;
 
4475
                        ZERO_STRUCT(r->out);
 
4476
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
4477
                        if (r->out.return_authenticator == NULL) {
 
4478
                        return NT_STATUS_NO_MEMORY;
 
4479
                        }
 
4480
 
 
4481
                        r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
 
4482
                        if (r->out.forest_trust_info == NULL) {
 
4483
                        return NT_STATUS_NO_MEMORY;
 
4484
                        }
 
4485
 
 
4486
                        r->out.result = _netr_GetForestTrustInformation(cli->pipes_struct, r);
 
4487
                        return NT_STATUS_OK;
 
4488
                }
 
4489
 
 
4490
                case NDR_NETR_LOGONSAMLOGONWITHFLAGS: {
 
4491
                        struct netr_LogonSamLogonWithFlags *r = (struct netr_LogonSamLogonWithFlags *)_r;
 
4492
                        ZERO_STRUCT(r->out);
 
4493
                        r->out.return_authenticator = r->in.return_authenticator;
 
4494
                        r->out.flags = r->in.flags;
 
4495
                        r->out.validation = talloc_zero(mem_ctx, union netr_Validation);
 
4496
                        if (r->out.validation == NULL) {
 
4497
                        return NT_STATUS_NO_MEMORY;
 
4498
                        }
 
4499
 
 
4500
                        r->out.authoritative = talloc_zero(mem_ctx, uint8_t);
 
4501
                        if (r->out.authoritative == NULL) {
 
4502
                        return NT_STATUS_NO_MEMORY;
 
4503
                        }
 
4504
 
 
4505
                        r->out.result = _netr_LogonSamLogonWithFlags(cli->pipes_struct, r);
 
4506
                        return NT_STATUS_OK;
 
4507
                }
 
4508
 
 
4509
                case NDR_NETR_SERVERGETTRUSTINFO: {
 
4510
                        struct netr_ServerGetTrustInfo *r = (struct netr_ServerGetTrustInfo *)_r;
 
4511
                        ZERO_STRUCT(r->out);
 
4512
                        r->out.return_authenticator = talloc_zero(mem_ctx, struct netr_Authenticator);
 
4513
                        if (r->out.return_authenticator == NULL) {
 
4514
                        return NT_STATUS_NO_MEMORY;
 
4515
                        }
 
4516
 
 
4517
                        r->out.new_owf_password = talloc_zero(mem_ctx, struct samr_Password);
 
4518
                        if (r->out.new_owf_password == NULL) {
 
4519
                        return NT_STATUS_NO_MEMORY;
 
4520
                        }
 
4521
 
 
4522
                        r->out.old_owf_password = talloc_zero(mem_ctx, struct samr_Password);
 
4523
                        if (r->out.old_owf_password == NULL) {
 
4524
                        return NT_STATUS_NO_MEMORY;
 
4525
                        }
 
4526
 
 
4527
                        r->out.trust_info = talloc_zero(mem_ctx, struct netr_TrustInfo *);
 
4528
                        if (r->out.trust_info == NULL) {
 
4529
                        return NT_STATUS_NO_MEMORY;
 
4530
                        }
 
4531
 
 
4532
                        r->out.result = _netr_ServerGetTrustInfo(cli->pipes_struct, r);
 
4533
                        return NT_STATUS_OK;
 
4534
                }
 
4535
 
 
4536
                default:
 
4537
                        return NT_STATUS_NOT_IMPLEMENTED;
 
4538
        }
 
4539
}
 
4540
 
 
4541
NTSTATUS rpc_netlogon_init(void)
 
4542
{
 
4543
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "netlogon", "netlogon", &ndr_table_netlogon, api_netlogon_cmds, sizeof(api_netlogon_cmds) / sizeof(struct api_struct));
 
4544
}