← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/srv_eventlog.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/srv_eventlog.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_eventlog.h"
8
 
 
9
 
static bool api_eventlog_ClearEventLogW(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 eventlog_ClearEventLogW *r;
17
 
 
18
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGW];
19
 
 
20
 
        r = talloc(talloc_tos(), struct eventlog_ClearEventLogW);
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(eventlog_ClearEventLogW, r);
45
 
        }
46
 
 
47
 
        r->out.result = _eventlog_ClearEventLogW(p, r);
48
 
 
49
 
        if (p->rng_fault_state) {
50
 
                talloc_free(r);
51
 
                /* Return true here, srv_pipe_hnd.c will take care */
52
 
                return true;
53
 
        }
54
 
 
55
 
        if (DEBUGLEVEL >= 10) {
56
 
                NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, r);
57
 
        }
58
 
 
59
 
        push = ndr_push_init_ctx(r, NULL);
60
 
        if (push == NULL) {
61
 
                talloc_free(r);
62
 
                return false;
63
 
        }
64
 
 
65
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
66
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
67
 
                talloc_free(r);
68
 
                return false;
69
 
        }
70
 
 
71
 
        blob = ndr_push_blob(push);
72
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
73
 
                talloc_free(r);
74
 
                return false;
75
 
        }
76
 
 
77
 
        talloc_free(r);
78
 
 
79
 
        return true;
80
 
}
81
 
 
82
 
static bool api_eventlog_BackupEventLogW(pipes_struct *p)
83
 
{
84
 
        const struct ndr_interface_call *call;
85
 
        struct ndr_pull *pull;
86
 
        struct ndr_push *push;
87
 
        enum ndr_err_code ndr_err;
88
 
        DATA_BLOB blob;
89
 
        struct eventlog_BackupEventLogW *r;
90
 
 
91
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGW];
92
 
 
93
 
        r = talloc(talloc_tos(), struct eventlog_BackupEventLogW);
94
 
        if (r == NULL) {
95
 
                return false;
96
 
        }
97
 
 
98
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
99
 
                talloc_free(r);
100
 
                return false;
101
 
        }
102
 
 
103
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
104
 
        if (pull == NULL) {
105
 
                talloc_free(r);
106
 
                return false;
107
 
        }
108
 
 
109
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
110
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
111
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
112
 
                talloc_free(r);
113
 
                return false;
114
 
        }
115
 
 
116
 
        if (DEBUGLEVEL >= 10) {
117
 
                NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, r);
118
 
        }
119
 
 
120
 
        r->out.result = _eventlog_BackupEventLogW(p, r);
121
 
 
122
 
        if (p->rng_fault_state) {
123
 
                talloc_free(r);
124
 
                /* Return true here, srv_pipe_hnd.c will take care */
125
 
                return true;
126
 
        }
127
 
 
128
 
        if (DEBUGLEVEL >= 10) {
129
 
                NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, r);
130
 
        }
131
 
 
132
 
        push = ndr_push_init_ctx(r, NULL);
133
 
        if (push == NULL) {
134
 
                talloc_free(r);
135
 
                return false;
136
 
        }
137
 
 
138
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
139
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
140
 
                talloc_free(r);
141
 
                return false;
142
 
        }
143
 
 
144
 
        blob = ndr_push_blob(push);
145
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
146
 
                talloc_free(r);
147
 
                return false;
148
 
        }
149
 
 
150
 
        talloc_free(r);
151
 
 
152
 
        return true;
153
 
}
154
 
 
155
 
static bool api_eventlog_CloseEventLog(pipes_struct *p)
156
 
{
157
 
        const struct ndr_interface_call *call;
158
 
        struct ndr_pull *pull;
159
 
        struct ndr_push *push;
160
 
        enum ndr_err_code ndr_err;
161
 
        DATA_BLOB blob;
162
 
        struct eventlog_CloseEventLog *r;
163
 
 
164
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLOSEEVENTLOG];
165
 
 
166
 
        r = talloc(talloc_tos(), struct eventlog_CloseEventLog);
167
 
        if (r == NULL) {
168
 
                return false;
169
 
        }
170
 
 
171
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
172
 
                talloc_free(r);
173
 
                return false;
174
 
        }
175
 
 
176
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
177
 
        if (pull == NULL) {
178
 
                talloc_free(r);
179
 
                return false;
180
 
        }
181
 
 
182
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
183
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
184
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
185
 
                talloc_free(r);
186
 
                return false;
187
 
        }
188
 
 
189
 
        if (DEBUGLEVEL >= 10) {
190
 
                NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, r);
191
 
        }
192
 
 
193
 
        ZERO_STRUCT(r->out);
194
 
        r->out.handle = r->in.handle;
195
 
        r->out.result = _eventlog_CloseEventLog(p, r);
196
 
 
197
 
        if (p->rng_fault_state) {
198
 
                talloc_free(r);
199
 
                /* Return true here, srv_pipe_hnd.c will take care */
200
 
                return true;
201
 
        }
202
 
 
203
 
        if (DEBUGLEVEL >= 10) {
204
 
                NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, r);
205
 
        }
206
 
 
207
 
        push = ndr_push_init_ctx(r, NULL);
208
 
        if (push == NULL) {
209
 
                talloc_free(r);
210
 
                return false;
211
 
        }
212
 
 
213
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
214
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
215
 
                talloc_free(r);
216
 
                return false;
217
 
        }
218
 
 
219
 
        blob = ndr_push_blob(push);
220
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
221
 
                talloc_free(r);
222
 
                return false;
223
 
        }
224
 
 
225
 
        talloc_free(r);
226
 
 
227
 
        return true;
228
 
}
229
 
 
230
 
static bool api_eventlog_DeregisterEventSource(pipes_struct *p)
231
 
{
232
 
        const struct ndr_interface_call *call;
233
 
        struct ndr_pull *pull;
234
 
        struct ndr_push *push;
235
 
        enum ndr_err_code ndr_err;
236
 
        DATA_BLOB blob;
237
 
        struct eventlog_DeregisterEventSource *r;
238
 
 
239
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTEREVENTSOURCE];
240
 
 
241
 
        r = talloc(talloc_tos(), struct eventlog_DeregisterEventSource);
242
 
        if (r == NULL) {
243
 
                return false;
244
 
        }
245
 
 
246
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
247
 
                talloc_free(r);
248
 
                return false;
249
 
        }
250
 
 
251
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
252
 
        if (pull == NULL) {
253
 
                talloc_free(r);
254
 
                return false;
255
 
        }
256
 
 
257
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
258
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
259
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
260
 
                talloc_free(r);
261
 
                return false;
262
 
        }
263
 
 
264
 
        if (DEBUGLEVEL >= 10) {
265
 
                NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, r);
266
 
        }
267
 
 
268
 
        ZERO_STRUCT(r->out);
269
 
        r->out.handle = r->in.handle;
270
 
        r->out.result = _eventlog_DeregisterEventSource(p, r);
271
 
 
272
 
        if (p->rng_fault_state) {
273
 
                talloc_free(r);
274
 
                /* Return true here, srv_pipe_hnd.c will take care */
275
 
                return true;
276
 
        }
277
 
 
278
 
        if (DEBUGLEVEL >= 10) {
279
 
                NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, r);
280
 
        }
281
 
 
282
 
        push = ndr_push_init_ctx(r, NULL);
283
 
        if (push == NULL) {
284
 
                talloc_free(r);
285
 
                return false;
286
 
        }
287
 
 
288
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
289
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
290
 
                talloc_free(r);
291
 
                return false;
292
 
        }
293
 
 
294
 
        blob = ndr_push_blob(push);
295
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
296
 
                talloc_free(r);
297
 
                return false;
298
 
        }
299
 
 
300
 
        talloc_free(r);
301
 
 
302
 
        return true;
303
 
}
304
 
 
305
 
static bool api_eventlog_GetNumRecords(pipes_struct *p)
306
 
{
307
 
        const struct ndr_interface_call *call;
308
 
        struct ndr_pull *pull;
309
 
        struct ndr_push *push;
310
 
        enum ndr_err_code ndr_err;
311
 
        DATA_BLOB blob;
312
 
        struct eventlog_GetNumRecords *r;
313
 
 
314
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETNUMRECORDS];
315
 
 
316
 
        r = talloc(talloc_tos(), struct eventlog_GetNumRecords);
317
 
        if (r == NULL) {
318
 
                return false;
319
 
        }
320
 
 
321
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
322
 
                talloc_free(r);
323
 
                return false;
324
 
        }
325
 
 
326
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
327
 
        if (pull == NULL) {
328
 
                talloc_free(r);
329
 
                return false;
330
 
        }
331
 
 
332
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
333
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
334
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
335
 
                talloc_free(r);
336
 
                return false;
337
 
        }
338
 
 
339
 
        if (DEBUGLEVEL >= 10) {
340
 
                NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, r);
341
 
        }
342
 
 
343
 
        ZERO_STRUCT(r->out);
344
 
        r->out.number = talloc_zero(r, uint32_t);
345
 
        if (r->out.number == NULL) {
346
 
                talloc_free(r);
347
 
                return false;
348
 
        }
349
 
 
350
 
        r->out.result = _eventlog_GetNumRecords(p, r);
351
 
 
352
 
        if (p->rng_fault_state) {
353
 
                talloc_free(r);
354
 
                /* Return true here, srv_pipe_hnd.c will take care */
355
 
                return true;
356
 
        }
357
 
 
358
 
        if (DEBUGLEVEL >= 10) {
359
 
                NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, r);
360
 
        }
361
 
 
362
 
        push = ndr_push_init_ctx(r, NULL);
363
 
        if (push == NULL) {
364
 
                talloc_free(r);
365
 
                return false;
366
 
        }
367
 
 
368
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
369
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
370
 
                talloc_free(r);
371
 
                return false;
372
 
        }
373
 
 
374
 
        blob = ndr_push_blob(push);
375
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
376
 
                talloc_free(r);
377
 
                return false;
378
 
        }
379
 
 
380
 
        talloc_free(r);
381
 
 
382
 
        return true;
383
 
}
384
 
 
385
 
static bool api_eventlog_GetOldestRecord(pipes_struct *p)
386
 
{
387
 
        const struct ndr_interface_call *call;
388
 
        struct ndr_pull *pull;
389
 
        struct ndr_push *push;
390
 
        enum ndr_err_code ndr_err;
391
 
        DATA_BLOB blob;
392
 
        struct eventlog_GetOldestRecord *r;
393
 
 
394
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETOLDESTRECORD];
395
 
 
396
 
        r = talloc(talloc_tos(), struct eventlog_GetOldestRecord);
397
 
        if (r == NULL) {
398
 
                return false;
399
 
        }
400
 
 
401
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
402
 
                talloc_free(r);
403
 
                return false;
404
 
        }
405
 
 
406
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
407
 
        if (pull == NULL) {
408
 
                talloc_free(r);
409
 
                return false;
410
 
        }
411
 
 
412
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
413
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
414
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
415
 
                talloc_free(r);
416
 
                return false;
417
 
        }
418
 
 
419
 
        if (DEBUGLEVEL >= 10) {
420
 
                NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, r);
421
 
        }
422
 
 
423
 
        ZERO_STRUCT(r->out);
424
 
        r->out.oldest_entry = talloc_zero(r, uint32_t);
425
 
        if (r->out.oldest_entry == NULL) {
426
 
                talloc_free(r);
427
 
                return false;
428
 
        }
429
 
 
430
 
        r->out.result = _eventlog_GetOldestRecord(p, r);
431
 
 
432
 
        if (p->rng_fault_state) {
433
 
                talloc_free(r);
434
 
                /* Return true here, srv_pipe_hnd.c will take care */
435
 
                return true;
436
 
        }
437
 
 
438
 
        if (DEBUGLEVEL >= 10) {
439
 
                NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, r);
440
 
        }
441
 
 
442
 
        push = ndr_push_init_ctx(r, NULL);
443
 
        if (push == NULL) {
444
 
                talloc_free(r);
445
 
                return false;
446
 
        }
447
 
 
448
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
449
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
450
 
                talloc_free(r);
451
 
                return false;
452
 
        }
453
 
 
454
 
        blob = ndr_push_blob(push);
455
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
456
 
                talloc_free(r);
457
 
                return false;
458
 
        }
459
 
 
460
 
        talloc_free(r);
461
 
 
462
 
        return true;
463
 
}
464
 
 
465
 
static bool api_eventlog_ChangeNotify(pipes_struct *p)
466
 
{
467
 
        const struct ndr_interface_call *call;
468
 
        struct ndr_pull *pull;
469
 
        struct ndr_push *push;
470
 
        enum ndr_err_code ndr_err;
471
 
        DATA_BLOB blob;
472
 
        struct eventlog_ChangeNotify *r;
473
 
 
474
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CHANGENOTIFY];
475
 
 
476
 
        r = talloc(talloc_tos(), struct eventlog_ChangeNotify);
477
 
        if (r == NULL) {
478
 
                return false;
479
 
        }
480
 
 
481
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
482
 
                talloc_free(r);
483
 
                return false;
484
 
        }
485
 
 
486
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
487
 
        if (pull == NULL) {
488
 
                talloc_free(r);
489
 
                return false;
490
 
        }
491
 
 
492
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
493
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
494
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
495
 
                talloc_free(r);
496
 
                return false;
497
 
        }
498
 
 
499
 
        if (DEBUGLEVEL >= 10) {
500
 
                NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, r);
501
 
        }
502
 
 
503
 
        r->out.result = _eventlog_ChangeNotify(p, r);
504
 
 
505
 
        if (p->rng_fault_state) {
506
 
                talloc_free(r);
507
 
                /* Return true here, srv_pipe_hnd.c will take care */
508
 
                return true;
509
 
        }
510
 
 
511
 
        if (DEBUGLEVEL >= 10) {
512
 
                NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, r);
513
 
        }
514
 
 
515
 
        push = ndr_push_init_ctx(r, NULL);
516
 
        if (push == NULL) {
517
 
                talloc_free(r);
518
 
                return false;
519
 
        }
520
 
 
521
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
522
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
523
 
                talloc_free(r);
524
 
                return false;
525
 
        }
526
 
 
527
 
        blob = ndr_push_blob(push);
528
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
529
 
                talloc_free(r);
530
 
                return false;
531
 
        }
532
 
 
533
 
        talloc_free(r);
534
 
 
535
 
        return true;
536
 
}
537
 
 
538
 
static bool api_eventlog_OpenEventLogW(pipes_struct *p)
539
 
{
540
 
        const struct ndr_interface_call *call;
541
 
        struct ndr_pull *pull;
542
 
        struct ndr_push *push;
543
 
        enum ndr_err_code ndr_err;
544
 
        DATA_BLOB blob;
545
 
        struct eventlog_OpenEventLogW *r;
546
 
 
547
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGW];
548
 
 
549
 
        r = talloc(talloc_tos(), struct eventlog_OpenEventLogW);
550
 
        if (r == NULL) {
551
 
                return false;
552
 
        }
553
 
 
554
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
555
 
                talloc_free(r);
556
 
                return false;
557
 
        }
558
 
 
559
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
560
 
        if (pull == NULL) {
561
 
                talloc_free(r);
562
 
                return false;
563
 
        }
564
 
 
565
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
566
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
567
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
568
 
                talloc_free(r);
569
 
                return false;
570
 
        }
571
 
 
572
 
        if (DEBUGLEVEL >= 10) {
573
 
                NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, r);
574
 
        }
575
 
 
576
 
        ZERO_STRUCT(r->out);
577
 
        r->out.handle = talloc_zero(r, struct policy_handle);
578
 
        if (r->out.handle == NULL) {
579
 
                talloc_free(r);
580
 
                return false;
581
 
        }
582
 
 
583
 
        r->out.result = _eventlog_OpenEventLogW(p, r);
584
 
 
585
 
        if (p->rng_fault_state) {
586
 
                talloc_free(r);
587
 
                /* Return true here, srv_pipe_hnd.c will take care */
588
 
                return true;
589
 
        }
590
 
 
591
 
        if (DEBUGLEVEL >= 10) {
592
 
                NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, r);
593
 
        }
594
 
 
595
 
        push = ndr_push_init_ctx(r, NULL);
596
 
        if (push == NULL) {
597
 
                talloc_free(r);
598
 
                return false;
599
 
        }
600
 
 
601
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
602
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
603
 
                talloc_free(r);
604
 
                return false;
605
 
        }
606
 
 
607
 
        blob = ndr_push_blob(push);
608
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
609
 
                talloc_free(r);
610
 
                return false;
611
 
        }
612
 
 
613
 
        talloc_free(r);
614
 
 
615
 
        return true;
616
 
}
617
 
 
618
 
static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
619
 
{
620
 
        const struct ndr_interface_call *call;
621
 
        struct ndr_pull *pull;
622
 
        struct ndr_push *push;
623
 
        enum ndr_err_code ndr_err;
624
 
        DATA_BLOB blob;
625
 
        struct eventlog_RegisterEventSourceW *r;
626
 
 
627
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEW];
628
 
 
629
 
        r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceW);
630
 
        if (r == NULL) {
631
 
                return false;
632
 
        }
633
 
 
634
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
635
 
                talloc_free(r);
636
 
                return false;
637
 
        }
638
 
 
639
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
640
 
        if (pull == NULL) {
641
 
                talloc_free(r);
642
 
                return false;
643
 
        }
644
 
 
645
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
646
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
647
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
648
 
                talloc_free(r);
649
 
                return false;
650
 
        }
651
 
 
652
 
        if (DEBUGLEVEL >= 10) {
653
 
                NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
654
 
        }
655
 
 
656
 
        ZERO_STRUCT(r->out);
657
 
        r->out.log_handle = talloc_zero(r, struct policy_handle);
658
 
        if (r->out.log_handle == NULL) {
659
 
                talloc_free(r);
660
 
                return false;
661
 
        }
662
 
 
663
 
        r->out.result = _eventlog_RegisterEventSourceW(p, r);
664
 
 
665
 
        if (p->rng_fault_state) {
666
 
                talloc_free(r);
667
 
                /* Return true here, srv_pipe_hnd.c will take care */
668
 
                return true;
669
 
        }
670
 
 
671
 
        if (DEBUGLEVEL >= 10) {
672
 
                NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, r);
673
 
        }
674
 
 
675
 
        push = ndr_push_init_ctx(r, NULL);
676
 
        if (push == NULL) {
677
 
                talloc_free(r);
678
 
                return false;
679
 
        }
680
 
 
681
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
682
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
683
 
                talloc_free(r);
684
 
                return false;
685
 
        }
686
 
 
687
 
        blob = ndr_push_blob(push);
688
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
689
 
                talloc_free(r);
690
 
                return false;
691
 
        }
692
 
 
693
 
        talloc_free(r);
694
 
 
695
 
        return true;
696
 
}
697
 
 
698
 
static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
699
 
{
700
 
        const struct ndr_interface_call *call;
701
 
        struct ndr_pull *pull;
702
 
        struct ndr_push *push;
703
 
        enum ndr_err_code ndr_err;
704
 
        DATA_BLOB blob;
705
 
        struct eventlog_OpenBackupEventLogW *r;
706
 
 
707
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGW];
708
 
 
709
 
        r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogW);
710
 
        if (r == NULL) {
711
 
                return false;
712
 
        }
713
 
 
714
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
715
 
                talloc_free(r);
716
 
                return false;
717
 
        }
718
 
 
719
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
720
 
        if (pull == NULL) {
721
 
                talloc_free(r);
722
 
                return false;
723
 
        }
724
 
 
725
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
726
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
727
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
728
 
                talloc_free(r);
729
 
                return false;
730
 
        }
731
 
 
732
 
        if (DEBUGLEVEL >= 10) {
733
 
                NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
734
 
        }
735
 
 
736
 
        ZERO_STRUCT(r->out);
737
 
        r->out.handle = talloc_zero(r, struct policy_handle);
738
 
        if (r->out.handle == NULL) {
739
 
                talloc_free(r);
740
 
                return false;
741
 
        }
742
 
 
743
 
        r->out.result = _eventlog_OpenBackupEventLogW(p, r);
744
 
 
745
 
        if (p->rng_fault_state) {
746
 
                talloc_free(r);
747
 
                /* Return true here, srv_pipe_hnd.c will take care */
748
 
                return true;
749
 
        }
750
 
 
751
 
        if (DEBUGLEVEL >= 10) {
752
 
                NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, r);
753
 
        }
754
 
 
755
 
        push = ndr_push_init_ctx(r, NULL);
756
 
        if (push == NULL) {
757
 
                talloc_free(r);
758
 
                return false;
759
 
        }
760
 
 
761
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
762
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
763
 
                talloc_free(r);
764
 
                return false;
765
 
        }
766
 
 
767
 
        blob = ndr_push_blob(push);
768
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
769
 
                talloc_free(r);
770
 
                return false;
771
 
        }
772
 
 
773
 
        talloc_free(r);
774
 
 
775
 
        return true;
776
 
}
777
 
 
778
 
static bool api_eventlog_ReadEventLogW(pipes_struct *p)
779
 
{
780
 
        const struct ndr_interface_call *call;
781
 
        struct ndr_pull *pull;
782
 
        struct ndr_push *push;
783
 
        enum ndr_err_code ndr_err;
784
 
        DATA_BLOB blob;
785
 
        struct eventlog_ReadEventLogW *r;
786
 
 
787
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGW];
788
 
 
789
 
        r = talloc(talloc_tos(), struct eventlog_ReadEventLogW);
790
 
        if (r == NULL) {
791
 
                return false;
792
 
        }
793
 
 
794
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
795
 
                talloc_free(r);
796
 
                return false;
797
 
        }
798
 
 
799
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
800
 
        if (pull == NULL) {
801
 
                talloc_free(r);
802
 
                return false;
803
 
        }
804
 
 
805
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
806
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
807
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
808
 
                talloc_free(r);
809
 
                return false;
810
 
        }
811
 
 
812
 
        if (DEBUGLEVEL >= 10) {
813
 
                NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, r);
814
 
        }
815
 
 
816
 
        ZERO_STRUCT(r->out);
817
 
        r->out.data = talloc_zero_array(r, uint8_t, r->in.number_of_bytes);
818
 
        if (r->out.data == NULL) {
819
 
                talloc_free(r);
820
 
                return false;
821
 
        }
822
 
 
823
 
        r->out.sent_size = talloc_zero(r, uint32_t);
824
 
        if (r->out.sent_size == NULL) {
825
 
                talloc_free(r);
826
 
                return false;
827
 
        }
828
 
 
829
 
        r->out.real_size = talloc_zero(r, uint32_t);
830
 
        if (r->out.real_size == NULL) {
831
 
                talloc_free(r);
832
 
                return false;
833
 
        }
834
 
 
835
 
        r->out.result = _eventlog_ReadEventLogW(p, r);
836
 
 
837
 
        if (p->rng_fault_state) {
838
 
                talloc_free(r);
839
 
                /* Return true here, srv_pipe_hnd.c will take care */
840
 
                return true;
841
 
        }
842
 
 
843
 
        if (DEBUGLEVEL >= 10) {
844
 
                NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, r);
845
 
        }
846
 
 
847
 
        push = ndr_push_init_ctx(r, NULL);
848
 
        if (push == NULL) {
849
 
                talloc_free(r);
850
 
                return false;
851
 
        }
852
 
 
853
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
854
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
855
 
                talloc_free(r);
856
 
                return false;
857
 
        }
858
 
 
859
 
        blob = ndr_push_blob(push);
860
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
861
 
                talloc_free(r);
862
 
                return false;
863
 
        }
864
 
 
865
 
        talloc_free(r);
866
 
 
867
 
        return true;
868
 
}
869
 
 
870
 
static bool api_eventlog_ReportEventW(pipes_struct *p)
871
 
{
872
 
        const struct ndr_interface_call *call;
873
 
        struct ndr_pull *pull;
874
 
        struct ndr_push *push;
875
 
        enum ndr_err_code ndr_err;
876
 
        DATA_BLOB blob;
877
 
        struct eventlog_ReportEventW *r;
878
 
 
879
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
880
 
 
881
 
        r = talloc(talloc_tos(), struct eventlog_ReportEventW);
882
 
        if (r == NULL) {
883
 
                return false;
884
 
        }
885
 
 
886
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
887
 
                talloc_free(r);
888
 
                return false;
889
 
        }
890
 
 
891
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
892
 
        if (pull == NULL) {
893
 
                talloc_free(r);
894
 
                return false;
895
 
        }
896
 
 
897
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
898
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
899
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
900
 
                talloc_free(r);
901
 
                return false;
902
 
        }
903
 
 
904
 
        if (DEBUGLEVEL >= 10) {
905
 
                NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
906
 
        }
907
 
 
908
 
        ZERO_STRUCT(r->out);
909
 
        r->out.record_number = r->in.record_number;
910
 
        r->out.time_written = r->in.time_written;
911
 
        r->out.result = _eventlog_ReportEventW(p, r);
912
 
 
913
 
        if (p->rng_fault_state) {
914
 
                talloc_free(r);
915
 
                /* Return true here, srv_pipe_hnd.c will take care */
916
 
                return true;
917
 
        }
918
 
 
919
 
        if (DEBUGLEVEL >= 10) {
920
 
                NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, r);
921
 
        }
922
 
 
923
 
        push = ndr_push_init_ctx(r, NULL);
924
 
        if (push == NULL) {
925
 
                talloc_free(r);
926
 
                return false;
927
 
        }
928
 
 
929
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
930
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
931
 
                talloc_free(r);
932
 
                return false;
933
 
        }
934
 
 
935
 
        blob = ndr_push_blob(push);
936
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
937
 
                talloc_free(r);
938
 
                return false;
939
 
        }
940
 
 
941
 
        talloc_free(r);
942
 
 
943
 
        return true;
944
 
}
945
 
 
946
 
static bool api_eventlog_ClearEventLogA(pipes_struct *p)
947
 
{
948
 
        const struct ndr_interface_call *call;
949
 
        struct ndr_pull *pull;
950
 
        struct ndr_push *push;
951
 
        enum ndr_err_code ndr_err;
952
 
        DATA_BLOB blob;
953
 
        struct eventlog_ClearEventLogA *r;
954
 
 
955
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGA];
956
 
 
957
 
        r = talloc(talloc_tos(), struct eventlog_ClearEventLogA);
958
 
        if (r == NULL) {
959
 
                return false;
960
 
        }
961
 
 
962
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
963
 
                talloc_free(r);
964
 
                return false;
965
 
        }
966
 
 
967
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
968
 
        if (pull == NULL) {
969
 
                talloc_free(r);
970
 
                return false;
971
 
        }
972
 
 
973
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
974
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
975
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
976
 
                talloc_free(r);
977
 
                return false;
978
 
        }
979
 
 
980
 
        if (DEBUGLEVEL >= 10) {
981
 
                NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, r);
982
 
        }
983
 
 
984
 
        r->out.result = _eventlog_ClearEventLogA(p, r);
985
 
 
986
 
        if (p->rng_fault_state) {
987
 
                talloc_free(r);
988
 
                /* Return true here, srv_pipe_hnd.c will take care */
989
 
                return true;
990
 
        }
991
 
 
992
 
        if (DEBUGLEVEL >= 10) {
993
 
                NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, r);
994
 
        }
995
 
 
996
 
        push = ndr_push_init_ctx(r, NULL);
997
 
        if (push == NULL) {
998
 
                talloc_free(r);
999
 
                return false;
1000
 
        }
1001
 
 
1002
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1003
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1004
 
                talloc_free(r);
1005
 
                return false;
1006
 
        }
1007
 
 
1008
 
        blob = ndr_push_blob(push);
1009
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1010
 
                talloc_free(r);
1011
 
                return false;
1012
 
        }
1013
 
 
1014
 
        talloc_free(r);
1015
 
 
1016
 
        return true;
1017
 
}
1018
 
 
1019
 
static bool api_eventlog_BackupEventLogA(pipes_struct *p)
1020
 
{
1021
 
        const struct ndr_interface_call *call;
1022
 
        struct ndr_pull *pull;
1023
 
        struct ndr_push *push;
1024
 
        enum ndr_err_code ndr_err;
1025
 
        DATA_BLOB blob;
1026
 
        struct eventlog_BackupEventLogA *r;
1027
 
 
1028
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGA];
1029
 
 
1030
 
        r = talloc(talloc_tos(), struct eventlog_BackupEventLogA);
1031
 
        if (r == NULL) {
1032
 
                return false;
1033
 
        }
1034
 
 
1035
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1036
 
                talloc_free(r);
1037
 
                return false;
1038
 
        }
1039
 
 
1040
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1041
 
        if (pull == NULL) {
1042
 
                talloc_free(r);
1043
 
                return false;
1044
 
        }
1045
 
 
1046
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1047
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1048
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1049
 
                talloc_free(r);
1050
 
                return false;
1051
 
        }
1052
 
 
1053
 
        if (DEBUGLEVEL >= 10) {
1054
 
                NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, r);
1055
 
        }
1056
 
 
1057
 
        r->out.result = _eventlog_BackupEventLogA(p, r);
1058
 
 
1059
 
        if (p->rng_fault_state) {
1060
 
                talloc_free(r);
1061
 
                /* Return true here, srv_pipe_hnd.c will take care */
1062
 
                return true;
1063
 
        }
1064
 
 
1065
 
        if (DEBUGLEVEL >= 10) {
1066
 
                NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, r);
1067
 
        }
1068
 
 
1069
 
        push = ndr_push_init_ctx(r, NULL);
1070
 
        if (push == NULL) {
1071
 
                talloc_free(r);
1072
 
                return false;
1073
 
        }
1074
 
 
1075
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1076
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1077
 
                talloc_free(r);
1078
 
                return false;
1079
 
        }
1080
 
 
1081
 
        blob = ndr_push_blob(push);
1082
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1083
 
                talloc_free(r);
1084
 
                return false;
1085
 
        }
1086
 
 
1087
 
        talloc_free(r);
1088
 
 
1089
 
        return true;
1090
 
}
1091
 
 
1092
 
static bool api_eventlog_OpenEventLogA(pipes_struct *p)
1093
 
{
1094
 
        const struct ndr_interface_call *call;
1095
 
        struct ndr_pull *pull;
1096
 
        struct ndr_push *push;
1097
 
        enum ndr_err_code ndr_err;
1098
 
        DATA_BLOB blob;
1099
 
        struct eventlog_OpenEventLogA *r;
1100
 
 
1101
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGA];
1102
 
 
1103
 
        r = talloc(talloc_tos(), struct eventlog_OpenEventLogA);
1104
 
        if (r == NULL) {
1105
 
                return false;
1106
 
        }
1107
 
 
1108
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1109
 
                talloc_free(r);
1110
 
                return false;
1111
 
        }
1112
 
 
1113
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1114
 
        if (pull == NULL) {
1115
 
                talloc_free(r);
1116
 
                return false;
1117
 
        }
1118
 
 
1119
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1120
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1121
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1122
 
                talloc_free(r);
1123
 
                return false;
1124
 
        }
1125
 
 
1126
 
        if (DEBUGLEVEL >= 10) {
1127
 
                NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, r);
1128
 
        }
1129
 
 
1130
 
        r->out.result = _eventlog_OpenEventLogA(p, r);
1131
 
 
1132
 
        if (p->rng_fault_state) {
1133
 
                talloc_free(r);
1134
 
                /* Return true here, srv_pipe_hnd.c will take care */
1135
 
                return true;
1136
 
        }
1137
 
 
1138
 
        if (DEBUGLEVEL >= 10) {
1139
 
                NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, r);
1140
 
        }
1141
 
 
1142
 
        push = ndr_push_init_ctx(r, NULL);
1143
 
        if (push == NULL) {
1144
 
                talloc_free(r);
1145
 
                return false;
1146
 
        }
1147
 
 
1148
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1149
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1150
 
                talloc_free(r);
1151
 
                return false;
1152
 
        }
1153
 
 
1154
 
        blob = ndr_push_blob(push);
1155
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1156
 
                talloc_free(r);
1157
 
                return false;
1158
 
        }
1159
 
 
1160
 
        talloc_free(r);
1161
 
 
1162
 
        return true;
1163
 
}
1164
 
 
1165
 
static bool api_eventlog_RegisterEventSourceA(pipes_struct *p)
1166
 
{
1167
 
        const struct ndr_interface_call *call;
1168
 
        struct ndr_pull *pull;
1169
 
        struct ndr_push *push;
1170
 
        enum ndr_err_code ndr_err;
1171
 
        DATA_BLOB blob;
1172
 
        struct eventlog_RegisterEventSourceA *r;
1173
 
 
1174
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEA];
1175
 
 
1176
 
        r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceA);
1177
 
        if (r == NULL) {
1178
 
                return false;
1179
 
        }
1180
 
 
1181
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1182
 
                talloc_free(r);
1183
 
                return false;
1184
 
        }
1185
 
 
1186
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1187
 
        if (pull == NULL) {
1188
 
                talloc_free(r);
1189
 
                return false;
1190
 
        }
1191
 
 
1192
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1193
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1194
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1195
 
                talloc_free(r);
1196
 
                return false;
1197
 
        }
1198
 
 
1199
 
        if (DEBUGLEVEL >= 10) {
1200
 
                NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, r);
1201
 
        }
1202
 
 
1203
 
        r->out.result = _eventlog_RegisterEventSourceA(p, r);
1204
 
 
1205
 
        if (p->rng_fault_state) {
1206
 
                talloc_free(r);
1207
 
                /* Return true here, srv_pipe_hnd.c will take care */
1208
 
                return true;
1209
 
        }
1210
 
 
1211
 
        if (DEBUGLEVEL >= 10) {
1212
 
                NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, r);
1213
 
        }
1214
 
 
1215
 
        push = ndr_push_init_ctx(r, NULL);
1216
 
        if (push == NULL) {
1217
 
                talloc_free(r);
1218
 
                return false;
1219
 
        }
1220
 
 
1221
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1222
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1223
 
                talloc_free(r);
1224
 
                return false;
1225
 
        }
1226
 
 
1227
 
        blob = ndr_push_blob(push);
1228
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1229
 
                talloc_free(r);
1230
 
                return false;
1231
 
        }
1232
 
 
1233
 
        talloc_free(r);
1234
 
 
1235
 
        return true;
1236
 
}
1237
 
 
1238
 
static bool api_eventlog_OpenBackupEventLogA(pipes_struct *p)
1239
 
{
1240
 
        const struct ndr_interface_call *call;
1241
 
        struct ndr_pull *pull;
1242
 
        struct ndr_push *push;
1243
 
        enum ndr_err_code ndr_err;
1244
 
        DATA_BLOB blob;
1245
 
        struct eventlog_OpenBackupEventLogA *r;
1246
 
 
1247
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGA];
1248
 
 
1249
 
        r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogA);
1250
 
        if (r == NULL) {
1251
 
                return false;
1252
 
        }
1253
 
 
1254
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1255
 
                talloc_free(r);
1256
 
                return false;
1257
 
        }
1258
 
 
1259
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1260
 
        if (pull == NULL) {
1261
 
                talloc_free(r);
1262
 
                return false;
1263
 
        }
1264
 
 
1265
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1266
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1267
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1268
 
                talloc_free(r);
1269
 
                return false;
1270
 
        }
1271
 
 
1272
 
        if (DEBUGLEVEL >= 10) {
1273
 
                NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, r);
1274
 
        }
1275
 
 
1276
 
        r->out.result = _eventlog_OpenBackupEventLogA(p, r);
1277
 
 
1278
 
        if (p->rng_fault_state) {
1279
 
                talloc_free(r);
1280
 
                /* Return true here, srv_pipe_hnd.c will take care */
1281
 
                return true;
1282
 
        }
1283
 
 
1284
 
        if (DEBUGLEVEL >= 10) {
1285
 
                NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, r);
1286
 
        }
1287
 
 
1288
 
        push = ndr_push_init_ctx(r, NULL);
1289
 
        if (push == NULL) {
1290
 
                talloc_free(r);
1291
 
                return false;
1292
 
        }
1293
 
 
1294
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1295
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1296
 
                talloc_free(r);
1297
 
                return false;
1298
 
        }
1299
 
 
1300
 
        blob = ndr_push_blob(push);
1301
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1302
 
                talloc_free(r);
1303
 
                return false;
1304
 
        }
1305
 
 
1306
 
        talloc_free(r);
1307
 
 
1308
 
        return true;
1309
 
}
1310
 
 
1311
 
static bool api_eventlog_ReadEventLogA(pipes_struct *p)
1312
 
{
1313
 
        const struct ndr_interface_call *call;
1314
 
        struct ndr_pull *pull;
1315
 
        struct ndr_push *push;
1316
 
        enum ndr_err_code ndr_err;
1317
 
        DATA_BLOB blob;
1318
 
        struct eventlog_ReadEventLogA *r;
1319
 
 
1320
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGA];
1321
 
 
1322
 
        r = talloc(talloc_tos(), struct eventlog_ReadEventLogA);
1323
 
        if (r == NULL) {
1324
 
                return false;
1325
 
        }
1326
 
 
1327
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1328
 
                talloc_free(r);
1329
 
                return false;
1330
 
        }
1331
 
 
1332
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1333
 
        if (pull == NULL) {
1334
 
                talloc_free(r);
1335
 
                return false;
1336
 
        }
1337
 
 
1338
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1339
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1340
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1341
 
                talloc_free(r);
1342
 
                return false;
1343
 
        }
1344
 
 
1345
 
        if (DEBUGLEVEL >= 10) {
1346
 
                NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, r);
1347
 
        }
1348
 
 
1349
 
        r->out.result = _eventlog_ReadEventLogA(p, r);
1350
 
 
1351
 
        if (p->rng_fault_state) {
1352
 
                talloc_free(r);
1353
 
                /* Return true here, srv_pipe_hnd.c will take care */
1354
 
                return true;
1355
 
        }
1356
 
 
1357
 
        if (DEBUGLEVEL >= 10) {
1358
 
                NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, r);
1359
 
        }
1360
 
 
1361
 
        push = ndr_push_init_ctx(r, NULL);
1362
 
        if (push == NULL) {
1363
 
                talloc_free(r);
1364
 
                return false;
1365
 
        }
1366
 
 
1367
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1368
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1369
 
                talloc_free(r);
1370
 
                return false;
1371
 
        }
1372
 
 
1373
 
        blob = ndr_push_blob(push);
1374
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1375
 
                talloc_free(r);
1376
 
                return false;
1377
 
        }
1378
 
 
1379
 
        talloc_free(r);
1380
 
 
1381
 
        return true;
1382
 
}
1383
 
 
1384
 
static bool api_eventlog_ReportEventA(pipes_struct *p)
1385
 
{
1386
 
        const struct ndr_interface_call *call;
1387
 
        struct ndr_pull *pull;
1388
 
        struct ndr_push *push;
1389
 
        enum ndr_err_code ndr_err;
1390
 
        DATA_BLOB blob;
1391
 
        struct eventlog_ReportEventA *r;
1392
 
 
1393
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTA];
1394
 
 
1395
 
        r = talloc(talloc_tos(), struct eventlog_ReportEventA);
1396
 
        if (r == NULL) {
1397
 
                return false;
1398
 
        }
1399
 
 
1400
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1401
 
                talloc_free(r);
1402
 
                return false;
1403
 
        }
1404
 
 
1405
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1406
 
        if (pull == NULL) {
1407
 
                talloc_free(r);
1408
 
                return false;
1409
 
        }
1410
 
 
1411
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1412
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1413
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1414
 
                talloc_free(r);
1415
 
                return false;
1416
 
        }
1417
 
 
1418
 
        if (DEBUGLEVEL >= 10) {
1419
 
                NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, r);
1420
 
        }
1421
 
 
1422
 
        r->out.result = _eventlog_ReportEventA(p, r);
1423
 
 
1424
 
        if (p->rng_fault_state) {
1425
 
                talloc_free(r);
1426
 
                /* Return true here, srv_pipe_hnd.c will take care */
1427
 
                return true;
1428
 
        }
1429
 
 
1430
 
        if (DEBUGLEVEL >= 10) {
1431
 
                NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, r);
1432
 
        }
1433
 
 
1434
 
        push = ndr_push_init_ctx(r, NULL);
1435
 
        if (push == NULL) {
1436
 
                talloc_free(r);
1437
 
                return false;
1438
 
        }
1439
 
 
1440
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1441
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1442
 
                talloc_free(r);
1443
 
                return false;
1444
 
        }
1445
 
 
1446
 
        blob = ndr_push_blob(push);
1447
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1448
 
                talloc_free(r);
1449
 
                return false;
1450
 
        }
1451
 
 
1452
 
        talloc_free(r);
1453
 
 
1454
 
        return true;
1455
 
}
1456
 
 
1457
 
static bool api_eventlog_RegisterClusterSvc(pipes_struct *p)
1458
 
{
1459
 
        const struct ndr_interface_call *call;
1460
 
        struct ndr_pull *pull;
1461
 
        struct ndr_push *push;
1462
 
        enum ndr_err_code ndr_err;
1463
 
        DATA_BLOB blob;
1464
 
        struct eventlog_RegisterClusterSvc *r;
1465
 
 
1466
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTERCLUSTERSVC];
1467
 
 
1468
 
        r = talloc(talloc_tos(), struct eventlog_RegisterClusterSvc);
1469
 
        if (r == NULL) {
1470
 
                return false;
1471
 
        }
1472
 
 
1473
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1474
 
                talloc_free(r);
1475
 
                return false;
1476
 
        }
1477
 
 
1478
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1479
 
        if (pull == NULL) {
1480
 
                talloc_free(r);
1481
 
                return false;
1482
 
        }
1483
 
 
1484
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1485
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1486
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1487
 
                talloc_free(r);
1488
 
                return false;
1489
 
        }
1490
 
 
1491
 
        if (DEBUGLEVEL >= 10) {
1492
 
                NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, r);
1493
 
        }
1494
 
 
1495
 
        r->out.result = _eventlog_RegisterClusterSvc(p, r);
1496
 
 
1497
 
        if (p->rng_fault_state) {
1498
 
                talloc_free(r);
1499
 
                /* Return true here, srv_pipe_hnd.c will take care */
1500
 
                return true;
1501
 
        }
1502
 
 
1503
 
        if (DEBUGLEVEL >= 10) {
1504
 
                NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, r);
1505
 
        }
1506
 
 
1507
 
        push = ndr_push_init_ctx(r, NULL);
1508
 
        if (push == NULL) {
1509
 
                talloc_free(r);
1510
 
                return false;
1511
 
        }
1512
 
 
1513
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1514
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1515
 
                talloc_free(r);
1516
 
                return false;
1517
 
        }
1518
 
 
1519
 
        blob = ndr_push_blob(push);
1520
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1521
 
                talloc_free(r);
1522
 
                return false;
1523
 
        }
1524
 
 
1525
 
        talloc_free(r);
1526
 
 
1527
 
        return true;
1528
 
}
1529
 
 
1530
 
static bool api_eventlog_DeregisterClusterSvc(pipes_struct *p)
1531
 
{
1532
 
        const struct ndr_interface_call *call;
1533
 
        struct ndr_pull *pull;
1534
 
        struct ndr_push *push;
1535
 
        enum ndr_err_code ndr_err;
1536
 
        DATA_BLOB blob;
1537
 
        struct eventlog_DeregisterClusterSvc *r;
1538
 
 
1539
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTERCLUSTERSVC];
1540
 
 
1541
 
        r = talloc(talloc_tos(), struct eventlog_DeregisterClusterSvc);
1542
 
        if (r == NULL) {
1543
 
                return false;
1544
 
        }
1545
 
 
1546
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1547
 
                talloc_free(r);
1548
 
                return false;
1549
 
        }
1550
 
 
1551
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1552
 
        if (pull == NULL) {
1553
 
                talloc_free(r);
1554
 
                return false;
1555
 
        }
1556
 
 
1557
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1558
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1559
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1560
 
                talloc_free(r);
1561
 
                return false;
1562
 
        }
1563
 
 
1564
 
        if (DEBUGLEVEL >= 10) {
1565
 
                NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, r);
1566
 
        }
1567
 
 
1568
 
        r->out.result = _eventlog_DeregisterClusterSvc(p, r);
1569
 
 
1570
 
        if (p->rng_fault_state) {
1571
 
                talloc_free(r);
1572
 
                /* Return true here, srv_pipe_hnd.c will take care */
1573
 
                return true;
1574
 
        }
1575
 
 
1576
 
        if (DEBUGLEVEL >= 10) {
1577
 
                NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, r);
1578
 
        }
1579
 
 
1580
 
        push = ndr_push_init_ctx(r, NULL);
1581
 
        if (push == NULL) {
1582
 
                talloc_free(r);
1583
 
                return false;
1584
 
        }
1585
 
 
1586
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1587
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1588
 
                talloc_free(r);
1589
 
                return false;
1590
 
        }
1591
 
 
1592
 
        blob = ndr_push_blob(push);
1593
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1594
 
                talloc_free(r);
1595
 
                return false;
1596
 
        }
1597
 
 
1598
 
        talloc_free(r);
1599
 
 
1600
 
        return true;
1601
 
}
1602
 
 
1603
 
static bool api_eventlog_WriteClusterEvents(pipes_struct *p)
1604
 
{
1605
 
        const struct ndr_interface_call *call;
1606
 
        struct ndr_pull *pull;
1607
 
        struct ndr_push *push;
1608
 
        enum ndr_err_code ndr_err;
1609
 
        DATA_BLOB blob;
1610
 
        struct eventlog_WriteClusterEvents *r;
1611
 
 
1612
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_WRITECLUSTEREVENTS];
1613
 
 
1614
 
        r = talloc(talloc_tos(), struct eventlog_WriteClusterEvents);
1615
 
        if (r == NULL) {
1616
 
                return false;
1617
 
        }
1618
 
 
1619
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1620
 
                talloc_free(r);
1621
 
                return false;
1622
 
        }
1623
 
 
1624
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1625
 
        if (pull == NULL) {
1626
 
                talloc_free(r);
1627
 
                return false;
1628
 
        }
1629
 
 
1630
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1631
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1632
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1633
 
                talloc_free(r);
1634
 
                return false;
1635
 
        }
1636
 
 
1637
 
        if (DEBUGLEVEL >= 10) {
1638
 
                NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, r);
1639
 
        }
1640
 
 
1641
 
        r->out.result = _eventlog_WriteClusterEvents(p, r);
1642
 
 
1643
 
        if (p->rng_fault_state) {
1644
 
                talloc_free(r);
1645
 
                /* Return true here, srv_pipe_hnd.c will take care */
1646
 
                return true;
1647
 
        }
1648
 
 
1649
 
        if (DEBUGLEVEL >= 10) {
1650
 
                NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, r);
1651
 
        }
1652
 
 
1653
 
        push = ndr_push_init_ctx(r, NULL);
1654
 
        if (push == NULL) {
1655
 
                talloc_free(r);
1656
 
                return false;
1657
 
        }
1658
 
 
1659
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1660
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1661
 
                talloc_free(r);
1662
 
                return false;
1663
 
        }
1664
 
 
1665
 
        blob = ndr_push_blob(push);
1666
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1667
 
                talloc_free(r);
1668
 
                return false;
1669
 
        }
1670
 
 
1671
 
        talloc_free(r);
1672
 
 
1673
 
        return true;
1674
 
}
1675
 
 
1676
 
static bool api_eventlog_GetLogInformation(pipes_struct *p)
1677
 
{
1678
 
        const struct ndr_interface_call *call;
1679
 
        struct ndr_pull *pull;
1680
 
        struct ndr_push *push;
1681
 
        enum ndr_err_code ndr_err;
1682
 
        DATA_BLOB blob;
1683
 
        struct eventlog_GetLogInformation *r;
1684
 
 
1685
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETLOGINFORMATION];
1686
 
 
1687
 
        r = talloc(talloc_tos(), struct eventlog_GetLogInformation);
1688
 
        if (r == NULL) {
1689
 
                return false;
1690
 
        }
1691
 
 
1692
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1693
 
                talloc_free(r);
1694
 
                return false;
1695
 
        }
1696
 
 
1697
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1698
 
        if (pull == NULL) {
1699
 
                talloc_free(r);
1700
 
                return false;
1701
 
        }
1702
 
 
1703
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1704
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1705
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1706
 
                talloc_free(r);
1707
 
                return false;
1708
 
        }
1709
 
 
1710
 
        if (DEBUGLEVEL >= 10) {
1711
 
                NDR_PRINT_IN_DEBUG(eventlog_GetLogInformation, r);
1712
 
        }
1713
 
 
1714
 
        ZERO_STRUCT(r->out);
1715
 
        r->out.buffer = talloc_zero_array(r, uint8_t, r->in.buf_size);
1716
 
        if (r->out.buffer == NULL) {
1717
 
                talloc_free(r);
1718
 
                return false;
1719
 
        }
1720
 
 
1721
 
        r->out.bytes_needed = talloc_zero(r, uint32_t);
1722
 
        if (r->out.bytes_needed == NULL) {
1723
 
                talloc_free(r);
1724
 
                return false;
1725
 
        }
1726
 
 
1727
 
        r->out.result = _eventlog_GetLogInformation(p, r);
1728
 
 
1729
 
        if (p->rng_fault_state) {
1730
 
                talloc_free(r);
1731
 
                /* Return true here, srv_pipe_hnd.c will take care */
1732
 
                return true;
1733
 
        }
1734
 
 
1735
 
        if (DEBUGLEVEL >= 10) {
1736
 
                NDR_PRINT_OUT_DEBUG(eventlog_GetLogInformation, r);
1737
 
        }
1738
 
 
1739
 
        push = ndr_push_init_ctx(r, NULL);
1740
 
        if (push == NULL) {
1741
 
                talloc_free(r);
1742
 
                return false;
1743
 
        }
1744
 
 
1745
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1746
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1747
 
                talloc_free(r);
1748
 
                return false;
1749
 
        }
1750
 
 
1751
 
        blob = ndr_push_blob(push);
1752
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1753
 
                talloc_free(r);
1754
 
                return false;
1755
 
        }
1756
 
 
1757
 
        talloc_free(r);
1758
 
 
1759
 
        return true;
1760
 
}
1761
 
 
1762
 
static bool api_eventlog_FlushEventLog(pipes_struct *p)
1763
 
{
1764
 
        const struct ndr_interface_call *call;
1765
 
        struct ndr_pull *pull;
1766
 
        struct ndr_push *push;
1767
 
        enum ndr_err_code ndr_err;
1768
 
        DATA_BLOB blob;
1769
 
        struct eventlog_FlushEventLog *r;
1770
 
 
1771
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_FLUSHEVENTLOG];
1772
 
 
1773
 
        r = talloc(talloc_tos(), struct eventlog_FlushEventLog);
1774
 
        if (r == NULL) {
1775
 
                return false;
1776
 
        }
1777
 
 
1778
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1779
 
                talloc_free(r);
1780
 
                return false;
1781
 
        }
1782
 
 
1783
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1784
 
        if (pull == NULL) {
1785
 
                talloc_free(r);
1786
 
                return false;
1787
 
        }
1788
 
 
1789
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1790
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1791
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1792
 
                talloc_free(r);
1793
 
                return false;
1794
 
        }
1795
 
 
1796
 
        if (DEBUGLEVEL >= 10) {
1797
 
                NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, r);
1798
 
        }
1799
 
 
1800
 
        r->out.result = _eventlog_FlushEventLog(p, r);
1801
 
 
1802
 
        if (p->rng_fault_state) {
1803
 
                talloc_free(r);
1804
 
                /* Return true here, srv_pipe_hnd.c will take care */
1805
 
                return true;
1806
 
        }
1807
 
 
1808
 
        if (DEBUGLEVEL >= 10) {
1809
 
                NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, r);
1810
 
        }
1811
 
 
1812
 
        push = ndr_push_init_ctx(r, NULL);
1813
 
        if (push == NULL) {
1814
 
                talloc_free(r);
1815
 
                return false;
1816
 
        }
1817
 
 
1818
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1819
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1820
 
                talloc_free(r);
1821
 
                return false;
1822
 
        }
1823
 
 
1824
 
        blob = ndr_push_blob(push);
1825
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1826
 
                talloc_free(r);
1827
 
                return false;
1828
 
        }
1829
 
 
1830
 
        talloc_free(r);
1831
 
 
1832
 
        return true;
1833
 
}
1834
 
 
1835
 
static bool api_eventlog_ReportEventAndSourceW(pipes_struct *p)
1836
 
{
1837
 
        const struct ndr_interface_call *call;
1838
 
        struct ndr_pull *pull;
1839
 
        struct ndr_push *push;
1840
 
        enum ndr_err_code ndr_err;
1841
 
        DATA_BLOB blob;
1842
 
        struct eventlog_ReportEventAndSourceW *r;
1843
 
 
1844
 
        call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTANDSOURCEW];
1845
 
 
1846
 
        r = talloc(talloc_tos(), struct eventlog_ReportEventAndSourceW);
1847
 
        if (r == NULL) {
1848
 
                return false;
1849
 
        }
1850
 
 
1851
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1852
 
                talloc_free(r);
1853
 
                return false;
1854
 
        }
1855
 
 
1856
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1857
 
        if (pull == NULL) {
1858
 
                talloc_free(r);
1859
 
                return false;
1860
 
        }
1861
 
 
1862
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1863
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1864
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1865
 
                talloc_free(r);
1866
 
                return false;
1867
 
        }
1868
 
 
1869
 
        if (DEBUGLEVEL >= 10) {
1870
 
                NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, r);
1871
 
        }
1872
 
 
1873
 
        ZERO_STRUCT(r->out);
1874
 
        r->out.record_number = r->in.record_number;
1875
 
        r->out.time_written = r->in.time_written;
1876
 
        r->out.result = _eventlog_ReportEventAndSourceW(p, r);
1877
 
 
1878
 
        if (p->rng_fault_state) {
1879
 
                talloc_free(r);
1880
 
                /* Return true here, srv_pipe_hnd.c will take care */
1881
 
                return true;
1882
 
        }
1883
 
 
1884
 
        if (DEBUGLEVEL >= 10) {
1885
 
                NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, r);
1886
 
        }
1887
 
 
1888
 
        push = ndr_push_init_ctx(r, NULL);
1889
 
        if (push == NULL) {
1890
 
                talloc_free(r);
1891
 
                return false;
1892
 
        }
1893
 
 
1894
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1895
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1896
 
                talloc_free(r);
1897
 
                return false;
1898
 
        }
1899
 
 
1900
 
        blob = ndr_push_blob(push);
1901
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1902
 
                talloc_free(r);
1903
 
                return false;
1904
 
        }
1905
 
 
1906
 
        talloc_free(r);
1907
 
 
1908
 
        return true;
1909
 
}
1910
 
 
1911
 
 
1912
 
/* Tables */
1913
 
static struct api_struct api_eventlog_cmds[] = 
1914
 
{
1915
 
        {"EVENTLOG_CLEAREVENTLOGW", NDR_EVENTLOG_CLEAREVENTLOGW, api_eventlog_ClearEventLogW},
1916
 
        {"EVENTLOG_BACKUPEVENTLOGW", NDR_EVENTLOG_BACKUPEVENTLOGW, api_eventlog_BackupEventLogW},
1917
 
        {"EVENTLOG_CLOSEEVENTLOG", NDR_EVENTLOG_CLOSEEVENTLOG, api_eventlog_CloseEventLog},
1918
 
        {"EVENTLOG_DEREGISTEREVENTSOURCE", NDR_EVENTLOG_DEREGISTEREVENTSOURCE, api_eventlog_DeregisterEventSource},
1919
 
        {"EVENTLOG_GETNUMRECORDS", NDR_EVENTLOG_GETNUMRECORDS, api_eventlog_GetNumRecords},
1920
 
        {"EVENTLOG_GETOLDESTRECORD", NDR_EVENTLOG_GETOLDESTRECORD, api_eventlog_GetOldestRecord},
1921
 
        {"EVENTLOG_CHANGENOTIFY", NDR_EVENTLOG_CHANGENOTIFY, api_eventlog_ChangeNotify},
1922
 
        {"EVENTLOG_OPENEVENTLOGW", NDR_EVENTLOG_OPENEVENTLOGW, api_eventlog_OpenEventLogW},
1923
 
        {"EVENTLOG_REGISTEREVENTSOURCEW", NDR_EVENTLOG_REGISTEREVENTSOURCEW, api_eventlog_RegisterEventSourceW},
1924
 
        {"EVENTLOG_OPENBACKUPEVENTLOGW", NDR_EVENTLOG_OPENBACKUPEVENTLOGW, api_eventlog_OpenBackupEventLogW},
1925
 
        {"EVENTLOG_READEVENTLOGW", NDR_EVENTLOG_READEVENTLOGW, api_eventlog_ReadEventLogW},
1926
 
        {"EVENTLOG_REPORTEVENTW", NDR_EVENTLOG_REPORTEVENTW, api_eventlog_ReportEventW},
1927
 
        {"EVENTLOG_CLEAREVENTLOGA", NDR_EVENTLOG_CLEAREVENTLOGA, api_eventlog_ClearEventLogA},
1928
 
        {"EVENTLOG_BACKUPEVENTLOGA", NDR_EVENTLOG_BACKUPEVENTLOGA, api_eventlog_BackupEventLogA},
1929
 
        {"EVENTLOG_OPENEVENTLOGA", NDR_EVENTLOG_OPENEVENTLOGA, api_eventlog_OpenEventLogA},
1930
 
        {"EVENTLOG_REGISTEREVENTSOURCEA", NDR_EVENTLOG_REGISTEREVENTSOURCEA, api_eventlog_RegisterEventSourceA},
1931
 
        {"EVENTLOG_OPENBACKUPEVENTLOGA", NDR_EVENTLOG_OPENBACKUPEVENTLOGA, api_eventlog_OpenBackupEventLogA},
1932
 
        {"EVENTLOG_READEVENTLOGA", NDR_EVENTLOG_READEVENTLOGA, api_eventlog_ReadEventLogA},
1933
 
        {"EVENTLOG_REPORTEVENTA", NDR_EVENTLOG_REPORTEVENTA, api_eventlog_ReportEventA},
1934
 
        {"EVENTLOG_REGISTERCLUSTERSVC", NDR_EVENTLOG_REGISTERCLUSTERSVC, api_eventlog_RegisterClusterSvc},
1935
 
        {"EVENTLOG_DEREGISTERCLUSTERSVC", NDR_EVENTLOG_DEREGISTERCLUSTERSVC, api_eventlog_DeregisterClusterSvc},
1936
 
        {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
1937
 
        {"EVENTLOG_GETLOGINFORMATION", NDR_EVENTLOG_GETLOGINFORMATION, api_eventlog_GetLogInformation},
1938
 
        {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
1939
 
        {"EVENTLOG_REPORTEVENTANDSOURCEW", NDR_EVENTLOG_REPORTEVENTANDSOURCEW, api_eventlog_ReportEventAndSourceW},
1940
 
};
1941
 
 
1942
 
void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
1943
 
{
1944
 
        *fns = api_eventlog_cmds;
1945
 
        *n_fns = sizeof(api_eventlog_cmds) / sizeof(struct api_struct);
1946
 
}
1947
 
 
1948
 
NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
1949
 
{
1950
 
        if (cli->pipes_struct == NULL) {
1951
 
                return NT_STATUS_INVALID_PARAMETER;
1952
 
        }
1953
 
 
1954
 
        switch (opnum)
1955
 
        {
1956
 
                case NDR_EVENTLOG_CLEAREVENTLOGW: {
1957
 
                        struct eventlog_ClearEventLogW *r = (struct eventlog_ClearEventLogW *)_r;
1958
 
                        r->out.result = _eventlog_ClearEventLogW(cli->pipes_struct, r);
1959
 
                        return NT_STATUS_OK;
1960
 
                }
1961
 
 
1962
 
                case NDR_EVENTLOG_BACKUPEVENTLOGW: {
1963
 
                        struct eventlog_BackupEventLogW *r = (struct eventlog_BackupEventLogW *)_r;
1964
 
                        r->out.result = _eventlog_BackupEventLogW(cli->pipes_struct, r);
1965
 
                        return NT_STATUS_OK;
1966
 
                }
1967
 
 
1968
 
                case NDR_EVENTLOG_CLOSEEVENTLOG: {
1969
 
                        struct eventlog_CloseEventLog *r = (struct eventlog_CloseEventLog *)_r;
1970
 
                        ZERO_STRUCT(r->out);
1971
 
                        r->out.handle = r->in.handle;
1972
 
                        r->out.result = _eventlog_CloseEventLog(cli->pipes_struct, r);
1973
 
                        return NT_STATUS_OK;
1974
 
                }
1975
 
 
1976
 
                case NDR_EVENTLOG_DEREGISTEREVENTSOURCE: {
1977
 
                        struct eventlog_DeregisterEventSource *r = (struct eventlog_DeregisterEventSource *)_r;
1978
 
                        ZERO_STRUCT(r->out);
1979
 
                        r->out.handle = r->in.handle;
1980
 
                        r->out.result = _eventlog_DeregisterEventSource(cli->pipes_struct, r);
1981
 
                        return NT_STATUS_OK;
1982
 
                }
1983
 
 
1984
 
                case NDR_EVENTLOG_GETNUMRECORDS: {
1985
 
                        struct eventlog_GetNumRecords *r = (struct eventlog_GetNumRecords *)_r;
1986
 
                        ZERO_STRUCT(r->out);
1987
 
                        r->out.number = talloc_zero(mem_ctx, uint32_t);
1988
 
                        if (r->out.number == NULL) {
1989
 
                        return NT_STATUS_NO_MEMORY;
1990
 
                        }
1991
 
 
1992
 
                        r->out.result = _eventlog_GetNumRecords(cli->pipes_struct, r);
1993
 
                        return NT_STATUS_OK;
1994
 
                }
1995
 
 
1996
 
                case NDR_EVENTLOG_GETOLDESTRECORD: {
1997
 
                        struct eventlog_GetOldestRecord *r = (struct eventlog_GetOldestRecord *)_r;
1998
 
                        ZERO_STRUCT(r->out);
1999
 
                        r->out.oldest_entry = talloc_zero(mem_ctx, uint32_t);
2000
 
                        if (r->out.oldest_entry == NULL) {
2001
 
                        return NT_STATUS_NO_MEMORY;
2002
 
                        }
2003
 
 
2004
 
                        r->out.result = _eventlog_GetOldestRecord(cli->pipes_struct, r);
2005
 
                        return NT_STATUS_OK;
2006
 
                }
2007
 
 
2008
 
                case NDR_EVENTLOG_CHANGENOTIFY: {
2009
 
                        struct eventlog_ChangeNotify *r = (struct eventlog_ChangeNotify *)_r;
2010
 
                        r->out.result = _eventlog_ChangeNotify(cli->pipes_struct, r);
2011
 
                        return NT_STATUS_OK;
2012
 
                }
2013
 
 
2014
 
                case NDR_EVENTLOG_OPENEVENTLOGW: {
2015
 
                        struct eventlog_OpenEventLogW *r = (struct eventlog_OpenEventLogW *)_r;
2016
 
                        ZERO_STRUCT(r->out);
2017
 
                        r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2018
 
                        if (r->out.handle == NULL) {
2019
 
                        return NT_STATUS_NO_MEMORY;
2020
 
                        }
2021
 
 
2022
 
                        r->out.result = _eventlog_OpenEventLogW(cli->pipes_struct, r);
2023
 
                        return NT_STATUS_OK;
2024
 
                }
2025
 
 
2026
 
                case NDR_EVENTLOG_REGISTEREVENTSOURCEW: {
2027
 
                        struct eventlog_RegisterEventSourceW *r = (struct eventlog_RegisterEventSourceW *)_r;
2028
 
                        ZERO_STRUCT(r->out);
2029
 
                        r->out.log_handle = talloc_zero(mem_ctx, struct policy_handle);
2030
 
                        if (r->out.log_handle == NULL) {
2031
 
                        return NT_STATUS_NO_MEMORY;
2032
 
                        }
2033
 
 
2034
 
                        r->out.result = _eventlog_RegisterEventSourceW(cli->pipes_struct, r);
2035
 
                        return NT_STATUS_OK;
2036
 
                }
2037
 
 
2038
 
                case NDR_EVENTLOG_OPENBACKUPEVENTLOGW: {
2039
 
                        struct eventlog_OpenBackupEventLogW *r = (struct eventlog_OpenBackupEventLogW *)_r;
2040
 
                        ZERO_STRUCT(r->out);
2041
 
                        r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2042
 
                        if (r->out.handle == NULL) {
2043
 
                        return NT_STATUS_NO_MEMORY;
2044
 
                        }
2045
 
 
2046
 
                        r->out.result = _eventlog_OpenBackupEventLogW(cli->pipes_struct, r);
2047
 
                        return NT_STATUS_OK;
2048
 
                }
2049
 
 
2050
 
                case NDR_EVENTLOG_READEVENTLOGW: {
2051
 
                        struct eventlog_ReadEventLogW *r = (struct eventlog_ReadEventLogW *)_r;
2052
 
                        ZERO_STRUCT(r->out);
2053
 
                        r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.number_of_bytes);
2054
 
                        if (r->out.data == NULL) {
2055
 
                        return NT_STATUS_NO_MEMORY;
2056
 
                        }
2057
 
 
2058
 
                        r->out.sent_size = talloc_zero(mem_ctx, uint32_t);
2059
 
                        if (r->out.sent_size == NULL) {
2060
 
                        return NT_STATUS_NO_MEMORY;
2061
 
                        }
2062
 
 
2063
 
                        r->out.real_size = talloc_zero(mem_ctx, uint32_t);
2064
 
                        if (r->out.real_size == NULL) {
2065
 
                        return NT_STATUS_NO_MEMORY;
2066
 
                        }
2067
 
 
2068
 
                        r->out.result = _eventlog_ReadEventLogW(cli->pipes_struct, r);
2069
 
                        return NT_STATUS_OK;
2070
 
                }
2071
 
 
2072
 
                case NDR_EVENTLOG_REPORTEVENTW: {
2073
 
                        struct eventlog_ReportEventW *r = (struct eventlog_ReportEventW *)_r;
2074
 
                        ZERO_STRUCT(r->out);
2075
 
                        r->out.record_number = r->in.record_number;
2076
 
                        r->out.time_written = r->in.time_written;
2077
 
                        r->out.result = _eventlog_ReportEventW(cli->pipes_struct, r);
2078
 
                        return NT_STATUS_OK;
2079
 
                }
2080
 
 
2081
 
                case NDR_EVENTLOG_CLEAREVENTLOGA: {
2082
 
                        struct eventlog_ClearEventLogA *r = (struct eventlog_ClearEventLogA *)_r;
2083
 
                        r->out.result = _eventlog_ClearEventLogA(cli->pipes_struct, r);
2084
 
                        return NT_STATUS_OK;
2085
 
                }
2086
 
 
2087
 
                case NDR_EVENTLOG_BACKUPEVENTLOGA: {
2088
 
                        struct eventlog_BackupEventLogA *r = (struct eventlog_BackupEventLogA *)_r;
2089
 
                        r->out.result = _eventlog_BackupEventLogA(cli->pipes_struct, r);
2090
 
                        return NT_STATUS_OK;
2091
 
                }
2092
 
 
2093
 
                case NDR_EVENTLOG_OPENEVENTLOGA: {
2094
 
                        struct eventlog_OpenEventLogA *r = (struct eventlog_OpenEventLogA *)_r;
2095
 
                        r->out.result = _eventlog_OpenEventLogA(cli->pipes_struct, r);
2096
 
                        return NT_STATUS_OK;
2097
 
                }
2098
 
 
2099
 
                case NDR_EVENTLOG_REGISTEREVENTSOURCEA: {
2100
 
                        struct eventlog_RegisterEventSourceA *r = (struct eventlog_RegisterEventSourceA *)_r;
2101
 
                        r->out.result = _eventlog_RegisterEventSourceA(cli->pipes_struct, r);
2102
 
                        return NT_STATUS_OK;
2103
 
                }
2104
 
 
2105
 
                case NDR_EVENTLOG_OPENBACKUPEVENTLOGA: {
2106
 
                        struct eventlog_OpenBackupEventLogA *r = (struct eventlog_OpenBackupEventLogA *)_r;
2107
 
                        r->out.result = _eventlog_OpenBackupEventLogA(cli->pipes_struct, r);
2108
 
                        return NT_STATUS_OK;
2109
 
                }
2110
 
 
2111
 
                case NDR_EVENTLOG_READEVENTLOGA: {
2112
 
                        struct eventlog_ReadEventLogA *r = (struct eventlog_ReadEventLogA *)_r;
2113
 
                        r->out.result = _eventlog_ReadEventLogA(cli->pipes_struct, r);
2114
 
                        return NT_STATUS_OK;
2115
 
                }
2116
 
 
2117
 
                case NDR_EVENTLOG_REPORTEVENTA: {
2118
 
                        struct eventlog_ReportEventA *r = (struct eventlog_ReportEventA *)_r;
2119
 
                        r->out.result = _eventlog_ReportEventA(cli->pipes_struct, r);
2120
 
                        return NT_STATUS_OK;
2121
 
                }
2122
 
 
2123
 
                case NDR_EVENTLOG_REGISTERCLUSTERSVC: {
2124
 
                        struct eventlog_RegisterClusterSvc *r = (struct eventlog_RegisterClusterSvc *)_r;
2125
 
                        r->out.result = _eventlog_RegisterClusterSvc(cli->pipes_struct, r);
2126
 
                        return NT_STATUS_OK;
2127
 
                }
2128
 
 
2129
 
                case NDR_EVENTLOG_DEREGISTERCLUSTERSVC: {
2130
 
                        struct eventlog_DeregisterClusterSvc *r = (struct eventlog_DeregisterClusterSvc *)_r;
2131
 
                        r->out.result = _eventlog_DeregisterClusterSvc(cli->pipes_struct, r);
2132
 
                        return NT_STATUS_OK;
2133
 
                }
2134
 
 
2135
 
                case NDR_EVENTLOG_WRITECLUSTEREVENTS: {
2136
 
                        struct eventlog_WriteClusterEvents *r = (struct eventlog_WriteClusterEvents *)_r;
2137
 
                        r->out.result = _eventlog_WriteClusterEvents(cli->pipes_struct, r);
2138
 
                        return NT_STATUS_OK;
2139
 
                }
2140
 
 
2141
 
                case NDR_EVENTLOG_GETLOGINFORMATION: {
2142
 
                        struct eventlog_GetLogInformation *r = (struct eventlog_GetLogInformation *)_r;
2143
 
                        ZERO_STRUCT(r->out);
2144
 
                        r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.buf_size);
2145
 
                        if (r->out.buffer == NULL) {
2146
 
                        return NT_STATUS_NO_MEMORY;
2147
 
                        }
2148
 
 
2149
 
                        r->out.bytes_needed = talloc_zero(mem_ctx, uint32_t);
2150
 
                        if (r->out.bytes_needed == NULL) {
2151
 
                        return NT_STATUS_NO_MEMORY;
2152
 
                        }
2153
 
 
2154
 
                        r->out.result = _eventlog_GetLogInformation(cli->pipes_struct, r);
2155
 
                        return NT_STATUS_OK;
2156
 
                }
2157
 
 
2158
 
                case NDR_EVENTLOG_FLUSHEVENTLOG: {
2159
 
                        struct eventlog_FlushEventLog *r = (struct eventlog_FlushEventLog *)_r;
2160
 
                        r->out.result = _eventlog_FlushEventLog(cli->pipes_struct, r);
2161
 
                        return NT_STATUS_OK;
2162
 
                }
2163
 
 
2164
 
                case NDR_EVENTLOG_REPORTEVENTANDSOURCEW: {
2165
 
                        struct eventlog_ReportEventAndSourceW *r = (struct eventlog_ReportEventAndSourceW *)_r;
2166
 
                        ZERO_STRUCT(r->out);
2167
 
                        r->out.record_number = r->in.record_number;
2168
 
                        r->out.time_written = r->in.time_written;
2169
 
                        r->out.result = _eventlog_ReportEventAndSourceW(cli->pipes_struct, r);
2170
 
                        return NT_STATUS_OK;
2171
 
                }
2172
 
 
2173
 
                default:
2174
 
                        return NT_STATUS_NOT_IMPLEMENTED;
2175
 
        }
2176
 
}
2177
 
 
2178
 
NTSTATUS rpc_eventlog_init(void)
2179
 
{
2180
 
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "eventlog", "eventlog", &ndr_table_eventlog, api_eventlog_cmds, sizeof(api_eventlog_cmds) / sizeof(struct api_struct));
2181
 
}