← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/srv_dcom.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/librpc/gen_ndr/srv_dcom.c
 
1
/*
 
2
 * Unix SMB/CIFS implementation.
 
3
 * server auto-generated by pidl. DO NOT MODIFY!
 
4
 */
 
5
 
 
6
#include "includes.h"
 
7
#include "ntdomain.h"
 
8
#include "librpc/gen_ndr/srv_dcom.h"
 
9
 
 
10
static bool api_UseProtSeq(struct pipes_struct *p)
 
11
{
 
12
        const struct ndr_interface_call *call;
 
13
        struct ndr_pull *pull;
 
14
        struct ndr_push *push;
 
15
        enum ndr_err_code ndr_err;
 
16
        struct UseProtSeq *r;
 
17
 
 
18
        call = &ndr_table_dcom_Unknown.calls[NDR_USEPROTSEQ];
 
19
 
 
20
        r = talloc(talloc_tos(), struct UseProtSeq);
 
21
        if (r == NULL) {
 
22
                return false;
 
23
        }
 
24
 
 
25
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
26
        if (pull == NULL) {
 
27
                talloc_free(r);
 
28
                return false;
 
29
        }
 
30
 
 
31
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
32
        if (p->endian) {
 
33
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
34
        }
 
35
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
36
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
37
                talloc_free(r);
 
38
                return false;
 
39
        }
 
40
 
 
41
        if (DEBUGLEVEL >= 10) {
 
42
                NDR_PRINT_FUNCTION_DEBUG(UseProtSeq, NDR_IN, r);
 
43
        }
 
44
 
 
45
        _UseProtSeq(p, r);
 
46
 
 
47
        if (p->rng_fault_state) {
 
48
                talloc_free(r);
 
49
                /* Return true here, srv_pipe_hnd.c will take care */
 
50
                return true;
 
51
        }
 
52
 
 
53
        if (DEBUGLEVEL >= 10) {
 
54
                NDR_PRINT_FUNCTION_DEBUG(UseProtSeq, NDR_OUT | NDR_SET_VALUES, r);
 
55
        }
 
56
 
 
57
        push = ndr_push_init_ctx(r);
 
58
        if (push == NULL) {
 
59
                talloc_free(r);
 
60
                return false;
 
61
        }
 
62
 
 
63
        /*
 
64
         * carry over the pointer count to the reply in case we are
 
65
         * using full pointer. See NDR specification for full pointers
 
66
         */
 
67
        push->ptr_count = pull->ptr_count;
 
68
 
 
69
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
70
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
71
                talloc_free(r);
 
72
                return false;
 
73
        }
 
74
 
 
75
        p->out_data.rdata = ndr_push_blob(push);
 
76
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
77
 
 
78
        talloc_free(r);
 
79
 
 
80
        return true;
 
81
}
 
82
 
 
83
static bool api_GetCustomProtseqInfo(struct pipes_struct *p)
 
84
{
 
85
        const struct ndr_interface_call *call;
 
86
        struct ndr_pull *pull;
 
87
        struct ndr_push *push;
 
88
        enum ndr_err_code ndr_err;
 
89
        struct GetCustomProtseqInfo *r;
 
90
 
 
91
        call = &ndr_table_dcom_Unknown.calls[NDR_GETCUSTOMPROTSEQINFO];
 
92
 
 
93
        r = talloc(talloc_tos(), struct GetCustomProtseqInfo);
 
94
        if (r == NULL) {
 
95
                return false;
 
96
        }
 
97
 
 
98
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
99
        if (pull == NULL) {
 
100
                talloc_free(r);
 
101
                return false;
 
102
        }
 
103
 
 
104
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
105
        if (p->endian) {
 
106
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
107
        }
 
108
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
109
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
110
                talloc_free(r);
 
111
                return false;
 
112
        }
 
113
 
 
114
        if (DEBUGLEVEL >= 10) {
 
115
                NDR_PRINT_FUNCTION_DEBUG(GetCustomProtseqInfo, NDR_IN, r);
 
116
        }
 
117
 
 
118
        _GetCustomProtseqInfo(p, r);
 
119
 
 
120
        if (p->rng_fault_state) {
 
121
                talloc_free(r);
 
122
                /* Return true here, srv_pipe_hnd.c will take care */
 
123
                return true;
 
124
        }
 
125
 
 
126
        if (DEBUGLEVEL >= 10) {
 
127
                NDR_PRINT_FUNCTION_DEBUG(GetCustomProtseqInfo, NDR_OUT | NDR_SET_VALUES, r);
 
128
        }
 
129
 
 
130
        push = ndr_push_init_ctx(r);
 
131
        if (push == NULL) {
 
132
                talloc_free(r);
 
133
                return false;
 
134
        }
 
135
 
 
136
        /*
 
137
         * carry over the pointer count to the reply in case we are
 
138
         * using full pointer. See NDR specification for full pointers
 
139
         */
 
140
        push->ptr_count = pull->ptr_count;
 
141
 
 
142
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
143
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
144
                talloc_free(r);
 
145
                return false;
 
146
        }
 
147
 
 
148
        p->out_data.rdata = ndr_push_blob(push);
 
149
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
150
 
 
151
        talloc_free(r);
 
152
 
 
153
        return true;
 
154
}
 
155
 
 
156
static bool api_UpdateResolverBindings(struct pipes_struct *p)
 
157
{
 
158
        const struct ndr_interface_call *call;
 
159
        struct ndr_pull *pull;
 
160
        struct ndr_push *push;
 
161
        enum ndr_err_code ndr_err;
 
162
        struct UpdateResolverBindings *r;
 
163
 
 
164
        call = &ndr_table_dcom_Unknown.calls[NDR_UPDATERESOLVERBINDINGS];
 
165
 
 
166
        r = talloc(talloc_tos(), struct UpdateResolverBindings);
 
167
        if (r == NULL) {
 
168
                return false;
 
169
        }
 
170
 
 
171
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
172
        if (pull == NULL) {
 
173
                talloc_free(r);
 
174
                return false;
 
175
        }
 
176
 
 
177
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
178
        if (p->endian) {
 
179
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
180
        }
 
181
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
182
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
183
                talloc_free(r);
 
184
                return false;
 
185
        }
 
186
 
 
187
        if (DEBUGLEVEL >= 10) {
 
188
                NDR_PRINT_FUNCTION_DEBUG(UpdateResolverBindings, NDR_IN, r);
 
189
        }
 
190
 
 
191
        _UpdateResolverBindings(p, r);
 
192
 
 
193
        if (p->rng_fault_state) {
 
194
                talloc_free(r);
 
195
                /* Return true here, srv_pipe_hnd.c will take care */
 
196
                return true;
 
197
        }
 
198
 
 
199
        if (DEBUGLEVEL >= 10) {
 
200
                NDR_PRINT_FUNCTION_DEBUG(UpdateResolverBindings, NDR_OUT | NDR_SET_VALUES, r);
 
201
        }
 
202
 
 
203
        push = ndr_push_init_ctx(r);
 
204
        if (push == NULL) {
 
205
                talloc_free(r);
 
206
                return false;
 
207
        }
 
208
 
 
209
        /*
 
210
         * carry over the pointer count to the reply in case we are
 
211
         * using full pointer. See NDR specification for full pointers
 
212
         */
 
213
        push->ptr_count = pull->ptr_count;
 
214
 
 
215
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
216
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
217
                talloc_free(r);
 
218
                return false;
 
219
        }
 
220
 
 
221
        p->out_data.rdata = ndr_push_blob(push);
 
222
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
223
 
 
224
        talloc_free(r);
 
225
 
 
226
        return true;
 
227
}
 
228
 
 
229
 
 
230
/* Tables */
 
231
static struct api_struct api_dcom_Unknown_cmds[] = 
 
232
{
 
233
        {"USEPROTSEQ", NDR_USEPROTSEQ, api_UseProtSeq},
 
234
        {"GETCUSTOMPROTSEQINFO", NDR_GETCUSTOMPROTSEQINFO, api_GetCustomProtseqInfo},
 
235
        {"UPDATERESOLVERBINDINGS", NDR_UPDATERESOLVERBINDINGS, api_UpdateResolverBindings},
 
236
};
 
237
 
 
238
void dcom_Unknown_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
239
{
 
240
        *fns = api_dcom_Unknown_cmds;
 
241
        *n_fns = sizeof(api_dcom_Unknown_cmds) / sizeof(struct api_struct);
 
242
}
 
243
 
 
244
NTSTATUS rpc_dcom_Unknown_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
245
{
 
246
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "dcom_Unknown", "dcom_Unknown", &ndr_table_dcom_Unknown, api_dcom_Unknown_cmds, sizeof(api_dcom_Unknown_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
247
}
 
248
 
 
249
NTSTATUS rpc_dcom_Unknown_shutdown(void)
 
250
{
 
251
        return rpc_srv_unregister(&ndr_table_dcom_Unknown);
 
252
}
 
253
static bool api_QueryInterface(struct pipes_struct *p)
 
254
{
 
255
        const struct ndr_interface_call *call;
 
256
        struct ndr_pull *pull;
 
257
        struct ndr_push *push;
 
258
        enum ndr_err_code ndr_err;
 
259
        struct QueryInterface *r;
 
260
 
 
261
        call = &ndr_table_IUnknown.calls[NDR_QUERYINTERFACE];
 
262
 
 
263
        r = talloc(talloc_tos(), struct QueryInterface);
 
264
        if (r == NULL) {
 
265
                return false;
 
266
        }
 
267
 
 
268
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
269
        if (pull == NULL) {
 
270
                talloc_free(r);
 
271
                return false;
 
272
        }
 
273
 
 
274
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
275
        if (p->endian) {
 
276
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
277
        }
 
278
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
279
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
280
                talloc_free(r);
 
281
                return false;
 
282
        }
 
283
 
 
284
        if (DEBUGLEVEL >= 10) {
 
285
                NDR_PRINT_FUNCTION_DEBUG(QueryInterface, NDR_IN, r);
 
286
        }
 
287
 
 
288
        ZERO_STRUCT(r->out);
 
289
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
290
        if (r->out.ORPCthat == NULL) {
 
291
                talloc_free(r);
 
292
                return false;
 
293
        }
 
294
 
 
295
        r->out.data = talloc_zero(r, struct MInterfacePointer *);
 
296
        if (r->out.data == NULL) {
 
297
                talloc_free(r);
 
298
                return false;
 
299
        }
 
300
 
 
301
        r->out.result = _QueryInterface(p, r);
 
302
 
 
303
        if (p->rng_fault_state) {
 
304
                talloc_free(r);
 
305
                /* Return true here, srv_pipe_hnd.c will take care */
 
306
                return true;
 
307
        }
 
308
 
 
309
        if (DEBUGLEVEL >= 10) {
 
310
                NDR_PRINT_FUNCTION_DEBUG(QueryInterface, NDR_OUT | NDR_SET_VALUES, r);
 
311
        }
 
312
 
 
313
        push = ndr_push_init_ctx(r);
 
314
        if (push == NULL) {
 
315
                talloc_free(r);
 
316
                return false;
 
317
        }
 
318
 
 
319
        /*
 
320
         * carry over the pointer count to the reply in case we are
 
321
         * using full pointer. See NDR specification for full pointers
 
322
         */
 
323
        push->ptr_count = pull->ptr_count;
 
324
 
 
325
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
326
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
327
                talloc_free(r);
 
328
                return false;
 
329
        }
 
330
 
 
331
        p->out_data.rdata = ndr_push_blob(push);
 
332
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
333
 
 
334
        talloc_free(r);
 
335
 
 
336
        return true;
 
337
}
 
338
 
 
339
static bool api_AddRef(struct pipes_struct *p)
 
340
{
 
341
        const struct ndr_interface_call *call;
 
342
        struct ndr_pull *pull;
 
343
        struct ndr_push *push;
 
344
        enum ndr_err_code ndr_err;
 
345
        struct AddRef *r;
 
346
 
 
347
        call = &ndr_table_IUnknown.calls[NDR_ADDREF];
 
348
 
 
349
        r = talloc(talloc_tos(), struct AddRef);
 
350
        if (r == NULL) {
 
351
                return false;
 
352
        }
 
353
 
 
354
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
355
        if (pull == NULL) {
 
356
                talloc_free(r);
 
357
                return false;
 
358
        }
 
359
 
 
360
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
361
        if (p->endian) {
 
362
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
363
        }
 
364
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
365
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
366
                talloc_free(r);
 
367
                return false;
 
368
        }
 
369
 
 
370
        if (DEBUGLEVEL >= 10) {
 
371
                NDR_PRINT_FUNCTION_DEBUG(AddRef, NDR_IN, r);
 
372
        }
 
373
 
 
374
        ZERO_STRUCT(r->out);
 
375
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
376
        if (r->out.ORPCthat == NULL) {
 
377
                talloc_free(r);
 
378
                return false;
 
379
        }
 
380
 
 
381
        r->out.result = _AddRef(p, r);
 
382
 
 
383
        if (p->rng_fault_state) {
 
384
                talloc_free(r);
 
385
                /* Return true here, srv_pipe_hnd.c will take care */
 
386
                return true;
 
387
        }
 
388
 
 
389
        if (DEBUGLEVEL >= 10) {
 
390
                NDR_PRINT_FUNCTION_DEBUG(AddRef, NDR_OUT | NDR_SET_VALUES, r);
 
391
        }
 
392
 
 
393
        push = ndr_push_init_ctx(r);
 
394
        if (push == NULL) {
 
395
                talloc_free(r);
 
396
                return false;
 
397
        }
 
398
 
 
399
        /*
 
400
         * carry over the pointer count to the reply in case we are
 
401
         * using full pointer. See NDR specification for full pointers
 
402
         */
 
403
        push->ptr_count = pull->ptr_count;
 
404
 
 
405
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
406
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
407
                talloc_free(r);
 
408
                return false;
 
409
        }
 
410
 
 
411
        p->out_data.rdata = ndr_push_blob(push);
 
412
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
413
 
 
414
        talloc_free(r);
 
415
 
 
416
        return true;
 
417
}
 
418
 
 
419
static bool api_Release(struct pipes_struct *p)
 
420
{
 
421
        const struct ndr_interface_call *call;
 
422
        struct ndr_pull *pull;
 
423
        struct ndr_push *push;
 
424
        enum ndr_err_code ndr_err;
 
425
        struct Release *r;
 
426
 
 
427
        call = &ndr_table_IUnknown.calls[NDR_RELEASE];
 
428
 
 
429
        r = talloc(talloc_tos(), struct Release);
 
430
        if (r == NULL) {
 
431
                return false;
 
432
        }
 
433
 
 
434
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
435
        if (pull == NULL) {
 
436
                talloc_free(r);
 
437
                return false;
 
438
        }
 
439
 
 
440
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
441
        if (p->endian) {
 
442
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
443
        }
 
444
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
445
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
446
                talloc_free(r);
 
447
                return false;
 
448
        }
 
449
 
 
450
        if (DEBUGLEVEL >= 10) {
 
451
                NDR_PRINT_FUNCTION_DEBUG(Release, NDR_IN, r);
 
452
        }
 
453
 
 
454
        ZERO_STRUCT(r->out);
 
455
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
456
        if (r->out.ORPCthat == NULL) {
 
457
                talloc_free(r);
 
458
                return false;
 
459
        }
 
460
 
 
461
        r->out.result = _Release(p, r);
 
462
 
 
463
        if (p->rng_fault_state) {
 
464
                talloc_free(r);
 
465
                /* Return true here, srv_pipe_hnd.c will take care */
 
466
                return true;
 
467
        }
 
468
 
 
469
        if (DEBUGLEVEL >= 10) {
 
470
                NDR_PRINT_FUNCTION_DEBUG(Release, NDR_OUT | NDR_SET_VALUES, r);
 
471
        }
 
472
 
 
473
        push = ndr_push_init_ctx(r);
 
474
        if (push == NULL) {
 
475
                talloc_free(r);
 
476
                return false;
 
477
        }
 
478
 
 
479
        /*
 
480
         * carry over the pointer count to the reply in case we are
 
481
         * using full pointer. See NDR specification for full pointers
 
482
         */
 
483
        push->ptr_count = pull->ptr_count;
 
484
 
 
485
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
486
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
487
                talloc_free(r);
 
488
                return false;
 
489
        }
 
490
 
 
491
        p->out_data.rdata = ndr_push_blob(push);
 
492
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
493
 
 
494
        talloc_free(r);
 
495
 
 
496
        return true;
 
497
}
 
498
 
 
499
 
 
500
/* Tables */
 
501
static struct api_struct api_IUnknown_cmds[] = 
 
502
{
 
503
        {"QUERYINTERFACE", NDR_QUERYINTERFACE, api_QueryInterface},
 
504
        {"ADDREF", NDR_ADDREF, api_AddRef},
 
505
        {"RELEASE", NDR_RELEASE, api_Release},
 
506
};
 
507
 
 
508
void IUnknown_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
509
{
 
510
        *fns = api_IUnknown_cmds;
 
511
        *n_fns = sizeof(api_IUnknown_cmds) / sizeof(struct api_struct);
 
512
}
 
513
 
 
514
NTSTATUS rpc_IUnknown_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
515
{
 
516
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IUnknown", "IUnknown", &ndr_table_IUnknown, api_IUnknown_cmds, sizeof(api_IUnknown_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
517
}
 
518
 
 
519
NTSTATUS rpc_IUnknown_shutdown(void)
 
520
{
 
521
        return rpc_srv_unregister(&ndr_table_IUnknown);
 
522
}
 
523
static bool api_CreateInstance(struct pipes_struct *p)
 
524
{
 
525
        const struct ndr_interface_call *call;
 
526
        struct ndr_pull *pull;
 
527
        struct ndr_push *push;
 
528
        enum ndr_err_code ndr_err;
 
529
        struct CreateInstance *r;
 
530
 
 
531
        call = &ndr_table_IClassFactory.calls[NDR_CREATEINSTANCE];
 
532
 
 
533
        r = talloc(talloc_tos(), struct CreateInstance);
 
534
        if (r == NULL) {
 
535
                return false;
 
536
        }
 
537
 
 
538
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
539
        if (pull == NULL) {
 
540
                talloc_free(r);
 
541
                return false;
 
542
        }
 
543
 
 
544
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
545
        if (p->endian) {
 
546
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
547
        }
 
548
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
549
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
550
                talloc_free(r);
 
551
                return false;
 
552
        }
 
553
 
 
554
        if (DEBUGLEVEL >= 10) {
 
555
                NDR_PRINT_FUNCTION_DEBUG(CreateInstance, NDR_IN, r);
 
556
        }
 
557
 
 
558
        ZERO_STRUCT(r->out);
 
559
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
560
        if (r->out.ORPCthat == NULL) {
 
561
                talloc_free(r);
 
562
                return false;
 
563
        }
 
564
 
 
565
        r->out.ppv = talloc_zero(r, struct MInterfacePointer);
 
566
        if (r->out.ppv == NULL) {
 
567
                talloc_free(r);
 
568
                return false;
 
569
        }
 
570
 
 
571
        r->out.result = _CreateInstance(p, r);
 
572
 
 
573
        if (p->rng_fault_state) {
 
574
                talloc_free(r);
 
575
                /* Return true here, srv_pipe_hnd.c will take care */
 
576
                return true;
 
577
        }
 
578
 
 
579
        if (DEBUGLEVEL >= 10) {
 
580
                NDR_PRINT_FUNCTION_DEBUG(CreateInstance, NDR_OUT | NDR_SET_VALUES, r);
 
581
        }
 
582
 
 
583
        push = ndr_push_init_ctx(r);
 
584
        if (push == NULL) {
 
585
                talloc_free(r);
 
586
                return false;
 
587
        }
 
588
 
 
589
        /*
 
590
         * carry over the pointer count to the reply in case we are
 
591
         * using full pointer. See NDR specification for full pointers
 
592
         */
 
593
        push->ptr_count = pull->ptr_count;
 
594
 
 
595
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
596
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
597
                talloc_free(r);
 
598
                return false;
 
599
        }
 
600
 
 
601
        p->out_data.rdata = ndr_push_blob(push);
 
602
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
603
 
 
604
        talloc_free(r);
 
605
 
 
606
        return true;
 
607
}
 
608
 
 
609
static bool api_RemoteCreateInstance(struct pipes_struct *p)
 
610
{
 
611
        const struct ndr_interface_call *call;
 
612
        struct ndr_pull *pull;
 
613
        struct ndr_push *push;
 
614
        enum ndr_err_code ndr_err;
 
615
        struct RemoteCreateInstance *r;
 
616
 
 
617
        call = &ndr_table_IClassFactory.calls[NDR_REMOTECREATEINSTANCE];
 
618
 
 
619
        r = talloc(talloc_tos(), struct RemoteCreateInstance);
 
620
        if (r == NULL) {
 
621
                return false;
 
622
        }
 
623
 
 
624
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
625
        if (pull == NULL) {
 
626
                talloc_free(r);
 
627
                return false;
 
628
        }
 
629
 
 
630
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
631
        if (p->endian) {
 
632
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
633
        }
 
634
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
635
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
636
                talloc_free(r);
 
637
                return false;
 
638
        }
 
639
 
 
640
        if (DEBUGLEVEL >= 10) {
 
641
                NDR_PRINT_FUNCTION_DEBUG(RemoteCreateInstance, NDR_IN, r);
 
642
        }
 
643
 
 
644
        ZERO_STRUCT(r->out);
 
645
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
646
        if (r->out.ORPCthat == NULL) {
 
647
                talloc_free(r);
 
648
                return false;
 
649
        }
 
650
 
 
651
        r->out.result = _RemoteCreateInstance(p, r);
 
652
 
 
653
        if (p->rng_fault_state) {
 
654
                talloc_free(r);
 
655
                /* Return true here, srv_pipe_hnd.c will take care */
 
656
                return true;
 
657
        }
 
658
 
 
659
        if (DEBUGLEVEL >= 10) {
 
660
                NDR_PRINT_FUNCTION_DEBUG(RemoteCreateInstance, NDR_OUT | NDR_SET_VALUES, r);
 
661
        }
 
662
 
 
663
        push = ndr_push_init_ctx(r);
 
664
        if (push == NULL) {
 
665
                talloc_free(r);
 
666
                return false;
 
667
        }
 
668
 
 
669
        /*
 
670
         * carry over the pointer count to the reply in case we are
 
671
         * using full pointer. See NDR specification for full pointers
 
672
         */
 
673
        push->ptr_count = pull->ptr_count;
 
674
 
 
675
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
676
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
677
                talloc_free(r);
 
678
                return false;
 
679
        }
 
680
 
 
681
        p->out_data.rdata = ndr_push_blob(push);
 
682
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
683
 
 
684
        talloc_free(r);
 
685
 
 
686
        return true;
 
687
}
 
688
 
 
689
static bool api_LockServer(struct pipes_struct *p)
 
690
{
 
691
        const struct ndr_interface_call *call;
 
692
        struct ndr_pull *pull;
 
693
        struct ndr_push *push;
 
694
        enum ndr_err_code ndr_err;
 
695
        struct LockServer *r;
 
696
 
 
697
        call = &ndr_table_IClassFactory.calls[NDR_LOCKSERVER];
 
698
 
 
699
        r = talloc(talloc_tos(), struct LockServer);
 
700
        if (r == NULL) {
 
701
                return false;
 
702
        }
 
703
 
 
704
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
705
        if (pull == NULL) {
 
706
                talloc_free(r);
 
707
                return false;
 
708
        }
 
709
 
 
710
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
711
        if (p->endian) {
 
712
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
713
        }
 
714
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
715
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
716
                talloc_free(r);
 
717
                return false;
 
718
        }
 
719
 
 
720
        if (DEBUGLEVEL >= 10) {
 
721
                NDR_PRINT_FUNCTION_DEBUG(LockServer, NDR_IN, r);
 
722
        }
 
723
 
 
724
        ZERO_STRUCT(r->out);
 
725
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
726
        if (r->out.ORPCthat == NULL) {
 
727
                talloc_free(r);
 
728
                return false;
 
729
        }
 
730
 
 
731
        r->out.result = _LockServer(p, r);
 
732
 
 
733
        if (p->rng_fault_state) {
 
734
                talloc_free(r);
 
735
                /* Return true here, srv_pipe_hnd.c will take care */
 
736
                return true;
 
737
        }
 
738
 
 
739
        if (DEBUGLEVEL >= 10) {
 
740
                NDR_PRINT_FUNCTION_DEBUG(LockServer, NDR_OUT | NDR_SET_VALUES, r);
 
741
        }
 
742
 
 
743
        push = ndr_push_init_ctx(r);
 
744
        if (push == NULL) {
 
745
                talloc_free(r);
 
746
                return false;
 
747
        }
 
748
 
 
749
        /*
 
750
         * carry over the pointer count to the reply in case we are
 
751
         * using full pointer. See NDR specification for full pointers
 
752
         */
 
753
        push->ptr_count = pull->ptr_count;
 
754
 
 
755
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
756
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
757
                talloc_free(r);
 
758
                return false;
 
759
        }
 
760
 
 
761
        p->out_data.rdata = ndr_push_blob(push);
 
762
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
763
 
 
764
        talloc_free(r);
 
765
 
 
766
        return true;
 
767
}
 
768
 
 
769
static bool api_RemoteLockServer(struct pipes_struct *p)
 
770
{
 
771
        const struct ndr_interface_call *call;
 
772
        struct ndr_pull *pull;
 
773
        struct ndr_push *push;
 
774
        enum ndr_err_code ndr_err;
 
775
        struct RemoteLockServer *r;
 
776
 
 
777
        call = &ndr_table_IClassFactory.calls[NDR_REMOTELOCKSERVER];
 
778
 
 
779
        r = talloc(talloc_tos(), struct RemoteLockServer);
 
780
        if (r == NULL) {
 
781
                return false;
 
782
        }
 
783
 
 
784
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
785
        if (pull == NULL) {
 
786
                talloc_free(r);
 
787
                return false;
 
788
        }
 
789
 
 
790
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
791
        if (p->endian) {
 
792
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
793
        }
 
794
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
795
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
796
                talloc_free(r);
 
797
                return false;
 
798
        }
 
799
 
 
800
        if (DEBUGLEVEL >= 10) {
 
801
                NDR_PRINT_FUNCTION_DEBUG(RemoteLockServer, NDR_IN, r);
 
802
        }
 
803
 
 
804
        ZERO_STRUCT(r->out);
 
805
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
806
        if (r->out.ORPCthat == NULL) {
 
807
                talloc_free(r);
 
808
                return false;
 
809
        }
 
810
 
 
811
        r->out.result = _RemoteLockServer(p, r);
 
812
 
 
813
        if (p->rng_fault_state) {
 
814
                talloc_free(r);
 
815
                /* Return true here, srv_pipe_hnd.c will take care */
 
816
                return true;
 
817
        }
 
818
 
 
819
        if (DEBUGLEVEL >= 10) {
 
820
                NDR_PRINT_FUNCTION_DEBUG(RemoteLockServer, NDR_OUT | NDR_SET_VALUES, r);
 
821
        }
 
822
 
 
823
        push = ndr_push_init_ctx(r);
 
824
        if (push == NULL) {
 
825
                talloc_free(r);
 
826
                return false;
 
827
        }
 
828
 
 
829
        /*
 
830
         * carry over the pointer count to the reply in case we are
 
831
         * using full pointer. See NDR specification for full pointers
 
832
         */
 
833
        push->ptr_count = pull->ptr_count;
 
834
 
 
835
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
836
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
837
                talloc_free(r);
 
838
                return false;
 
839
        }
 
840
 
 
841
        p->out_data.rdata = ndr_push_blob(push);
 
842
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
843
 
 
844
        talloc_free(r);
 
845
 
 
846
        return true;
 
847
}
 
848
 
 
849
 
 
850
/* Tables */
 
851
static struct api_struct api_IClassFactory_cmds[] = 
 
852
{
 
853
        {"CREATEINSTANCE", NDR_CREATEINSTANCE, api_CreateInstance},
 
854
        {"REMOTECREATEINSTANCE", NDR_REMOTECREATEINSTANCE, api_RemoteCreateInstance},
 
855
        {"LOCKSERVER", NDR_LOCKSERVER, api_LockServer},
 
856
        {"REMOTELOCKSERVER", NDR_REMOTELOCKSERVER, api_RemoteLockServer},
 
857
};
 
858
 
 
859
void IClassFactory_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
860
{
 
861
        *fns = api_IClassFactory_cmds;
 
862
        *n_fns = sizeof(api_IClassFactory_cmds) / sizeof(struct api_struct);
 
863
}
 
864
 
 
865
NTSTATUS rpc_IClassFactory_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
866
{
 
867
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IClassFactory", "IClassFactory", &ndr_table_IClassFactory, api_IClassFactory_cmds, sizeof(api_IClassFactory_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
868
}
 
869
 
 
870
NTSTATUS rpc_IClassFactory_shutdown(void)
 
871
{
 
872
        return rpc_srv_unregister(&ndr_table_IClassFactory);
 
873
}
 
874
static bool api_RemQueryInterface(struct pipes_struct *p)
 
875
{
 
876
        const struct ndr_interface_call *call;
 
877
        struct ndr_pull *pull;
 
878
        struct ndr_push *push;
 
879
        enum ndr_err_code ndr_err;
 
880
        struct RemQueryInterface *r;
 
881
 
 
882
        call = &ndr_table_IRemUnknown.calls[NDR_REMQUERYINTERFACE];
 
883
 
 
884
        r = talloc(talloc_tos(), struct RemQueryInterface);
 
885
        if (r == NULL) {
 
886
                return false;
 
887
        }
 
888
 
 
889
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
890
        if (pull == NULL) {
 
891
                talloc_free(r);
 
892
                return false;
 
893
        }
 
894
 
 
895
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
896
        if (p->endian) {
 
897
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
898
        }
 
899
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
900
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
901
                talloc_free(r);
 
902
                return false;
 
903
        }
 
904
 
 
905
        if (DEBUGLEVEL >= 10) {
 
906
                NDR_PRINT_FUNCTION_DEBUG(RemQueryInterface, NDR_IN, r);
 
907
        }
 
908
 
 
909
        ZERO_STRUCT(r->out);
 
910
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
911
        if (r->out.ORPCthat == NULL) {
 
912
                talloc_free(r);
 
913
                return false;
 
914
        }
 
915
 
 
916
        r->out.ip = talloc_zero_array(r, struct MInterfacePointer, r->in.cIids);
 
917
        if (r->out.ip == NULL) {
 
918
                talloc_free(r);
 
919
                return false;
 
920
        }
 
921
 
 
922
        r->out.result = _RemQueryInterface(p, r);
 
923
 
 
924
        if (p->rng_fault_state) {
 
925
                talloc_free(r);
 
926
                /* Return true here, srv_pipe_hnd.c will take care */
 
927
                return true;
 
928
        }
 
929
 
 
930
        if (DEBUGLEVEL >= 10) {
 
931
                NDR_PRINT_FUNCTION_DEBUG(RemQueryInterface, NDR_OUT | NDR_SET_VALUES, r);
 
932
        }
 
933
 
 
934
        push = ndr_push_init_ctx(r);
 
935
        if (push == NULL) {
 
936
                talloc_free(r);
 
937
                return false;
 
938
        }
 
939
 
 
940
        /*
 
941
         * carry over the pointer count to the reply in case we are
 
942
         * using full pointer. See NDR specification for full pointers
 
943
         */
 
944
        push->ptr_count = pull->ptr_count;
 
945
 
 
946
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
947
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
948
                talloc_free(r);
 
949
                return false;
 
950
        }
 
951
 
 
952
        p->out_data.rdata = ndr_push_blob(push);
 
953
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
954
 
 
955
        talloc_free(r);
 
956
 
 
957
        return true;
 
958
}
 
959
 
 
960
static bool api_RemAddRef(struct pipes_struct *p)
 
961
{
 
962
        const struct ndr_interface_call *call;
 
963
        struct ndr_pull *pull;
 
964
        struct ndr_push *push;
 
965
        enum ndr_err_code ndr_err;
 
966
        struct RemAddRef *r;
 
967
 
 
968
        call = &ndr_table_IRemUnknown.calls[NDR_REMADDREF];
 
969
 
 
970
        r = talloc(talloc_tos(), struct RemAddRef);
 
971
        if (r == NULL) {
 
972
                return false;
 
973
        }
 
974
 
 
975
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
976
        if (pull == NULL) {
 
977
                talloc_free(r);
 
978
                return false;
 
979
        }
 
980
 
 
981
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
982
        if (p->endian) {
 
983
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
984
        }
 
985
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
986
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
987
                talloc_free(r);
 
988
                return false;
 
989
        }
 
990
 
 
991
        if (DEBUGLEVEL >= 10) {
 
992
                NDR_PRINT_FUNCTION_DEBUG(RemAddRef, NDR_IN, r);
 
993
        }
 
994
 
 
995
        ZERO_STRUCT(r->out);
 
996
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
997
        if (r->out.ORPCthat == NULL) {
 
998
                talloc_free(r);
 
999
                return false;
 
1000
        }
 
1001
 
 
1002
        r->out.pResults = talloc_zero_array(r, WERROR, r->in.cInterfaceRefs);
 
1003
        if (r->out.pResults == NULL) {
 
1004
                talloc_free(r);
 
1005
                return false;
 
1006
        }
 
1007
 
 
1008
        r->out.result = _RemAddRef(p, r);
 
1009
 
 
1010
        if (p->rng_fault_state) {
 
1011
                talloc_free(r);
 
1012
                /* Return true here, srv_pipe_hnd.c will take care */
 
1013
                return true;
 
1014
        }
 
1015
 
 
1016
        if (DEBUGLEVEL >= 10) {
 
1017
                NDR_PRINT_FUNCTION_DEBUG(RemAddRef, NDR_OUT | NDR_SET_VALUES, r);
 
1018
        }
 
1019
 
 
1020
        push = ndr_push_init_ctx(r);
 
1021
        if (push == NULL) {
 
1022
                talloc_free(r);
 
1023
                return false;
 
1024
        }
 
1025
 
 
1026
        /*
 
1027
         * carry over the pointer count to the reply in case we are
 
1028
         * using full pointer. See NDR specification for full pointers
 
1029
         */
 
1030
        push->ptr_count = pull->ptr_count;
 
1031
 
 
1032
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1033
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1034
                talloc_free(r);
 
1035
                return false;
 
1036
        }
 
1037
 
 
1038
        p->out_data.rdata = ndr_push_blob(push);
 
1039
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1040
 
 
1041
        talloc_free(r);
 
1042
 
 
1043
        return true;
 
1044
}
 
1045
 
 
1046
static bool api_RemRelease(struct pipes_struct *p)
 
1047
{
 
1048
        const struct ndr_interface_call *call;
 
1049
        struct ndr_pull *pull;
 
1050
        struct ndr_push *push;
 
1051
        enum ndr_err_code ndr_err;
 
1052
        struct RemRelease *r;
 
1053
 
 
1054
        call = &ndr_table_IRemUnknown.calls[NDR_REMRELEASE];
 
1055
 
 
1056
        r = talloc(talloc_tos(), struct RemRelease);
 
1057
        if (r == NULL) {
 
1058
                return false;
 
1059
        }
 
1060
 
 
1061
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1062
        if (pull == NULL) {
 
1063
                talloc_free(r);
 
1064
                return false;
 
1065
        }
 
1066
 
 
1067
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1068
        if (p->endian) {
 
1069
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1070
        }
 
1071
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1072
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1073
                talloc_free(r);
 
1074
                return false;
 
1075
        }
 
1076
 
 
1077
        if (DEBUGLEVEL >= 10) {
 
1078
                NDR_PRINT_FUNCTION_DEBUG(RemRelease, NDR_IN, r);
 
1079
        }
 
1080
 
 
1081
        ZERO_STRUCT(r->out);
 
1082
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1083
        if (r->out.ORPCthat == NULL) {
 
1084
                talloc_free(r);
 
1085
                return false;
 
1086
        }
 
1087
 
 
1088
        r->out.result = _RemRelease(p, r);
 
1089
 
 
1090
        if (p->rng_fault_state) {
 
1091
                talloc_free(r);
 
1092
                /* Return true here, srv_pipe_hnd.c will take care */
 
1093
                return true;
 
1094
        }
 
1095
 
 
1096
        if (DEBUGLEVEL >= 10) {
 
1097
                NDR_PRINT_FUNCTION_DEBUG(RemRelease, NDR_OUT | NDR_SET_VALUES, r);
 
1098
        }
 
1099
 
 
1100
        push = ndr_push_init_ctx(r);
 
1101
        if (push == NULL) {
 
1102
                talloc_free(r);
 
1103
                return false;
 
1104
        }
 
1105
 
 
1106
        /*
 
1107
         * carry over the pointer count to the reply in case we are
 
1108
         * using full pointer. See NDR specification for full pointers
 
1109
         */
 
1110
        push->ptr_count = pull->ptr_count;
 
1111
 
 
1112
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1113
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1114
                talloc_free(r);
 
1115
                return false;
 
1116
        }
 
1117
 
 
1118
        p->out_data.rdata = ndr_push_blob(push);
 
1119
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1120
 
 
1121
        talloc_free(r);
 
1122
 
 
1123
        return true;
 
1124
}
 
1125
 
 
1126
 
 
1127
/* Tables */
 
1128
static struct api_struct api_IRemUnknown_cmds[] = 
 
1129
{
 
1130
        {"REMQUERYINTERFACE", NDR_REMQUERYINTERFACE, api_RemQueryInterface},
 
1131
        {"REMADDREF", NDR_REMADDREF, api_RemAddRef},
 
1132
        {"REMRELEASE", NDR_REMRELEASE, api_RemRelease},
 
1133
};
 
1134
 
 
1135
void IRemUnknown_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1136
{
 
1137
        *fns = api_IRemUnknown_cmds;
 
1138
        *n_fns = sizeof(api_IRemUnknown_cmds) / sizeof(struct api_struct);
 
1139
}
 
1140
 
 
1141
NTSTATUS rpc_IRemUnknown_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1142
{
 
1143
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IRemUnknown", "IRemUnknown", &ndr_table_IRemUnknown, api_IRemUnknown_cmds, sizeof(api_IRemUnknown_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1144
}
 
1145
 
 
1146
NTSTATUS rpc_IRemUnknown_shutdown(void)
 
1147
{
 
1148
        return rpc_srv_unregister(&ndr_table_IRemUnknown);
 
1149
}
 
1150
static bool api_GetClassObject(struct pipes_struct *p)
 
1151
{
 
1152
        const struct ndr_interface_call *call;
 
1153
        struct ndr_pull *pull;
 
1154
        struct ndr_push *push;
 
1155
        enum ndr_err_code ndr_err;
 
1156
        struct GetClassObject *r;
 
1157
 
 
1158
        call = &ndr_table_IClassActivator.calls[NDR_GETCLASSOBJECT];
 
1159
 
 
1160
        r = talloc(talloc_tos(), struct GetClassObject);
 
1161
        if (r == NULL) {
 
1162
                return false;
 
1163
        }
 
1164
 
 
1165
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1166
        if (pull == NULL) {
 
1167
                talloc_free(r);
 
1168
                return false;
 
1169
        }
 
1170
 
 
1171
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1172
        if (p->endian) {
 
1173
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1174
        }
 
1175
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1176
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1177
                talloc_free(r);
 
1178
                return false;
 
1179
        }
 
1180
 
 
1181
        if (DEBUGLEVEL >= 10) {
 
1182
                NDR_PRINT_FUNCTION_DEBUG(GetClassObject, NDR_IN, r);
 
1183
        }
 
1184
 
 
1185
        ZERO_STRUCT(r->out);
 
1186
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1187
        if (r->out.ORPCthat == NULL) {
 
1188
                talloc_free(r);
 
1189
                return false;
 
1190
        }
 
1191
 
 
1192
        r->out.data = talloc_zero(r, struct MInterfacePointer);
 
1193
        if (r->out.data == NULL) {
 
1194
                talloc_free(r);
 
1195
                return false;
 
1196
        }
 
1197
 
 
1198
        _GetClassObject(p, r);
 
1199
 
 
1200
        if (p->rng_fault_state) {
 
1201
                talloc_free(r);
 
1202
                /* Return true here, srv_pipe_hnd.c will take care */
 
1203
                return true;
 
1204
        }
 
1205
 
 
1206
        if (DEBUGLEVEL >= 10) {
 
1207
                NDR_PRINT_FUNCTION_DEBUG(GetClassObject, NDR_OUT | NDR_SET_VALUES, r);
 
1208
        }
 
1209
 
 
1210
        push = ndr_push_init_ctx(r);
 
1211
        if (push == NULL) {
 
1212
                talloc_free(r);
 
1213
                return false;
 
1214
        }
 
1215
 
 
1216
        /*
 
1217
         * carry over the pointer count to the reply in case we are
 
1218
         * using full pointer. See NDR specification for full pointers
 
1219
         */
 
1220
        push->ptr_count = pull->ptr_count;
 
1221
 
 
1222
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1223
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1224
                talloc_free(r);
 
1225
                return false;
 
1226
        }
 
1227
 
 
1228
        p->out_data.rdata = ndr_push_blob(push);
 
1229
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1230
 
 
1231
        talloc_free(r);
 
1232
 
 
1233
        return true;
 
1234
}
 
1235
 
 
1236
 
 
1237
/* Tables */
 
1238
static struct api_struct api_IClassActivator_cmds[] = 
 
1239
{
 
1240
        {"GETCLASSOBJECT", NDR_GETCLASSOBJECT, api_GetClassObject},
 
1241
};
 
1242
 
 
1243
void IClassActivator_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1244
{
 
1245
        *fns = api_IClassActivator_cmds;
 
1246
        *n_fns = sizeof(api_IClassActivator_cmds) / sizeof(struct api_struct);
 
1247
}
 
1248
 
 
1249
NTSTATUS rpc_IClassActivator_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1250
{
 
1251
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IClassActivator", "IClassActivator", &ndr_table_IClassActivator, api_IClassActivator_cmds, sizeof(api_IClassActivator_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1252
}
 
1253
 
 
1254
NTSTATUS rpc_IClassActivator_shutdown(void)
 
1255
{
 
1256
        return rpc_srv_unregister(&ndr_table_IClassActivator);
 
1257
}
 
1258
static bool api_ISCMLocalActivator_CreateInstance(struct pipes_struct *p)
 
1259
{
 
1260
        const struct ndr_interface_call *call;
 
1261
        struct ndr_pull *pull;
 
1262
        struct ndr_push *push;
 
1263
        enum ndr_err_code ndr_err;
 
1264
        struct ISCMLocalActivator_CreateInstance *r;
 
1265
 
 
1266
        call = &ndr_table_ISCMLocalActivator.calls[NDR_ISCMLOCALACTIVATOR_CREATEINSTANCE];
 
1267
 
 
1268
        r = talloc(talloc_tos(), struct ISCMLocalActivator_CreateInstance);
 
1269
        if (r == NULL) {
 
1270
                return false;
 
1271
        }
 
1272
 
 
1273
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1274
        if (pull == NULL) {
 
1275
                talloc_free(r);
 
1276
                return false;
 
1277
        }
 
1278
 
 
1279
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1280
        if (p->endian) {
 
1281
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1282
        }
 
1283
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1284
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1285
                talloc_free(r);
 
1286
                return false;
 
1287
        }
 
1288
 
 
1289
        if (DEBUGLEVEL >= 10) {
 
1290
                NDR_PRINT_FUNCTION_DEBUG(ISCMLocalActivator_CreateInstance, NDR_IN, r);
 
1291
        }
 
1292
 
 
1293
        ZERO_STRUCT(r->out);
 
1294
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1295
        if (r->out.ORPCthat == NULL) {
 
1296
                talloc_free(r);
 
1297
                return false;
 
1298
        }
 
1299
 
 
1300
        r->out.result = _ISCMLocalActivator_CreateInstance(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_FUNCTION_DEBUG(ISCMLocalActivator_CreateInstance, NDR_OUT | NDR_SET_VALUES, r);
 
1310
        }
 
1311
 
 
1312
        push = ndr_push_init_ctx(r);
 
1313
        if (push == NULL) {
 
1314
                talloc_free(r);
 
1315
                return false;
 
1316
        }
 
1317
 
 
1318
        /*
 
1319
         * carry over the pointer count to the reply in case we are
 
1320
         * using full pointer. See NDR specification for full pointers
 
1321
         */
 
1322
        push->ptr_count = pull->ptr_count;
 
1323
 
 
1324
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1325
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1326
                talloc_free(r);
 
1327
                return false;
 
1328
        }
 
1329
 
 
1330
        p->out_data.rdata = ndr_push_blob(push);
 
1331
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1332
 
 
1333
        talloc_free(r);
 
1334
 
 
1335
        return true;
 
1336
}
 
1337
 
 
1338
 
 
1339
/* Tables */
 
1340
static struct api_struct api_ISCMLocalActivator_cmds[] = 
 
1341
{
 
1342
        {"ISCMLOCALACTIVATOR_CREATEINSTANCE", NDR_ISCMLOCALACTIVATOR_CREATEINSTANCE, api_ISCMLocalActivator_CreateInstance},
 
1343
};
 
1344
 
 
1345
void ISCMLocalActivator_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1346
{
 
1347
        *fns = api_ISCMLocalActivator_cmds;
 
1348
        *n_fns = sizeof(api_ISCMLocalActivator_cmds) / sizeof(struct api_struct);
 
1349
}
 
1350
 
 
1351
NTSTATUS rpc_ISCMLocalActivator_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1352
{
 
1353
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ISCMLocalActivator", "ISCMLocalActivator", &ndr_table_ISCMLocalActivator, api_ISCMLocalActivator_cmds, sizeof(api_ISCMLocalActivator_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1354
}
 
1355
 
 
1356
NTSTATUS rpc_ISCMLocalActivator_shutdown(void)
 
1357
{
 
1358
        return rpc_srv_unregister(&ndr_table_ISCMLocalActivator);
 
1359
}
 
1360
static bool api_IMachineLocalActivator_foo(struct pipes_struct *p)
 
1361
{
 
1362
        const struct ndr_interface_call *call;
 
1363
        struct ndr_pull *pull;
 
1364
        struct ndr_push *push;
 
1365
        enum ndr_err_code ndr_err;
 
1366
        struct IMachineLocalActivator_foo *r;
 
1367
 
 
1368
        call = &ndr_table_IMachineLocalActivator.calls[NDR_IMACHINELOCALACTIVATOR_FOO];
 
1369
 
 
1370
        r = talloc(talloc_tos(), struct IMachineLocalActivator_foo);
 
1371
        if (r == NULL) {
 
1372
                return false;
 
1373
        }
 
1374
 
 
1375
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1376
        if (pull == NULL) {
 
1377
                talloc_free(r);
 
1378
                return false;
 
1379
        }
 
1380
 
 
1381
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1382
        if (p->endian) {
 
1383
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1384
        }
 
1385
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1386
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1387
                talloc_free(r);
 
1388
                return false;
 
1389
        }
 
1390
 
 
1391
        if (DEBUGLEVEL >= 10) {
 
1392
                NDR_PRINT_FUNCTION_DEBUG(IMachineLocalActivator_foo, NDR_IN, r);
 
1393
        }
 
1394
 
 
1395
        r->out.result = _IMachineLocalActivator_foo(p, r);
 
1396
 
 
1397
        if (p->rng_fault_state) {
 
1398
                talloc_free(r);
 
1399
                /* Return true here, srv_pipe_hnd.c will take care */
 
1400
                return true;
 
1401
        }
 
1402
 
 
1403
        if (DEBUGLEVEL >= 10) {
 
1404
                NDR_PRINT_FUNCTION_DEBUG(IMachineLocalActivator_foo, NDR_OUT | NDR_SET_VALUES, r);
 
1405
        }
 
1406
 
 
1407
        push = ndr_push_init_ctx(r);
 
1408
        if (push == NULL) {
 
1409
                talloc_free(r);
 
1410
                return false;
 
1411
        }
 
1412
 
 
1413
        /*
 
1414
         * carry over the pointer count to the reply in case we are
 
1415
         * using full pointer. See NDR specification for full pointers
 
1416
         */
 
1417
        push->ptr_count = pull->ptr_count;
 
1418
 
 
1419
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1420
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1421
                talloc_free(r);
 
1422
                return false;
 
1423
        }
 
1424
 
 
1425
        p->out_data.rdata = ndr_push_blob(push);
 
1426
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1427
 
 
1428
        talloc_free(r);
 
1429
 
 
1430
        return true;
 
1431
}
 
1432
 
 
1433
 
 
1434
/* Tables */
 
1435
static struct api_struct api_IMachineLocalActivator_cmds[] = 
 
1436
{
 
1437
        {"IMACHINELOCALACTIVATOR_FOO", NDR_IMACHINELOCALACTIVATOR_FOO, api_IMachineLocalActivator_foo},
 
1438
};
 
1439
 
 
1440
void IMachineLocalActivator_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1441
{
 
1442
        *fns = api_IMachineLocalActivator_cmds;
 
1443
        *n_fns = sizeof(api_IMachineLocalActivator_cmds) / sizeof(struct api_struct);
 
1444
}
 
1445
 
 
1446
NTSTATUS rpc_IMachineLocalActivator_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1447
{
 
1448
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IMachineLocalActivator", "IMachineLocalActivator", &ndr_table_IMachineLocalActivator, api_IMachineLocalActivator_cmds, sizeof(api_IMachineLocalActivator_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1449
}
 
1450
 
 
1451
NTSTATUS rpc_IMachineLocalActivator_shutdown(void)
 
1452
{
 
1453
        return rpc_srv_unregister(&ndr_table_IMachineLocalActivator);
 
1454
}
 
1455
static bool api_ILocalObjectExporter_Foo(struct pipes_struct *p)
 
1456
{
 
1457
        const struct ndr_interface_call *call;
 
1458
        struct ndr_pull *pull;
 
1459
        struct ndr_push *push;
 
1460
        enum ndr_err_code ndr_err;
 
1461
        struct ILocalObjectExporter_Foo *r;
 
1462
 
 
1463
        call = &ndr_table_ILocalObjectExporter.calls[NDR_ILOCALOBJECTEXPORTER_FOO];
 
1464
 
 
1465
        r = talloc(talloc_tos(), struct ILocalObjectExporter_Foo);
 
1466
        if (r == NULL) {
 
1467
                return false;
 
1468
        }
 
1469
 
 
1470
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1471
        if (pull == NULL) {
 
1472
                talloc_free(r);
 
1473
                return false;
 
1474
        }
 
1475
 
 
1476
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1477
        if (p->endian) {
 
1478
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1479
        }
 
1480
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1481
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1482
                talloc_free(r);
 
1483
                return false;
 
1484
        }
 
1485
 
 
1486
        if (DEBUGLEVEL >= 10) {
 
1487
                NDR_PRINT_FUNCTION_DEBUG(ILocalObjectExporter_Foo, NDR_IN, r);
 
1488
        }
 
1489
 
 
1490
        r->out.result = _ILocalObjectExporter_Foo(p, r);
 
1491
 
 
1492
        if (p->rng_fault_state) {
 
1493
                talloc_free(r);
 
1494
                /* Return true here, srv_pipe_hnd.c will take care */
 
1495
                return true;
 
1496
        }
 
1497
 
 
1498
        if (DEBUGLEVEL >= 10) {
 
1499
                NDR_PRINT_FUNCTION_DEBUG(ILocalObjectExporter_Foo, NDR_OUT | NDR_SET_VALUES, r);
 
1500
        }
 
1501
 
 
1502
        push = ndr_push_init_ctx(r);
 
1503
        if (push == NULL) {
 
1504
                talloc_free(r);
 
1505
                return false;
 
1506
        }
 
1507
 
 
1508
        /*
 
1509
         * carry over the pointer count to the reply in case we are
 
1510
         * using full pointer. See NDR specification for full pointers
 
1511
         */
 
1512
        push->ptr_count = pull->ptr_count;
 
1513
 
 
1514
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1515
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1516
                talloc_free(r);
 
1517
                return false;
 
1518
        }
 
1519
 
 
1520
        p->out_data.rdata = ndr_push_blob(push);
 
1521
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1522
 
 
1523
        talloc_free(r);
 
1524
 
 
1525
        return true;
 
1526
}
 
1527
 
 
1528
 
 
1529
/* Tables */
 
1530
static struct api_struct api_ILocalObjectExporter_cmds[] = 
 
1531
{
 
1532
        {"ILOCALOBJECTEXPORTER_FOO", NDR_ILOCALOBJECTEXPORTER_FOO, api_ILocalObjectExporter_Foo},
 
1533
};
 
1534
 
 
1535
void ILocalObjectExporter_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1536
{
 
1537
        *fns = api_ILocalObjectExporter_cmds;
 
1538
        *n_fns = sizeof(api_ILocalObjectExporter_cmds) / sizeof(struct api_struct);
 
1539
}
 
1540
 
 
1541
NTSTATUS rpc_ILocalObjectExporter_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1542
{
 
1543
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ILocalObjectExporter", "ILocalObjectExporter", &ndr_table_ILocalObjectExporter, api_ILocalObjectExporter_cmds, sizeof(api_ILocalObjectExporter_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1544
}
 
1545
 
 
1546
NTSTATUS rpc_ILocalObjectExporter_shutdown(void)
 
1547
{
 
1548
        return rpc_srv_unregister(&ndr_table_ILocalObjectExporter);
 
1549
}
 
1550
static bool api_ISystemActivatorRemoteCreateInstance(struct pipes_struct *p)
 
1551
{
 
1552
        const struct ndr_interface_call *call;
 
1553
        struct ndr_pull *pull;
 
1554
        struct ndr_push *push;
 
1555
        enum ndr_err_code ndr_err;
 
1556
        struct ISystemActivatorRemoteCreateInstance *r;
 
1557
 
 
1558
        call = &ndr_table_ISystemActivator.calls[NDR_ISYSTEMACTIVATORREMOTECREATEINSTANCE];
 
1559
 
 
1560
        r = talloc(talloc_tos(), struct ISystemActivatorRemoteCreateInstance);
 
1561
        if (r == NULL) {
 
1562
                return false;
 
1563
        }
 
1564
 
 
1565
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1566
        if (pull == NULL) {
 
1567
                talloc_free(r);
 
1568
                return false;
 
1569
        }
 
1570
 
 
1571
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1572
        if (p->endian) {
 
1573
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1574
        }
 
1575
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1576
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1577
                talloc_free(r);
 
1578
                return false;
 
1579
        }
 
1580
 
 
1581
        if (DEBUGLEVEL >= 10) {
 
1582
                NDR_PRINT_FUNCTION_DEBUG(ISystemActivatorRemoteCreateInstance, NDR_IN, r);
 
1583
        }
 
1584
 
 
1585
        ZERO_STRUCT(r->out);
 
1586
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1587
        if (r->out.ORPCthat == NULL) {
 
1588
                talloc_free(r);
 
1589
                return false;
 
1590
        }
 
1591
 
 
1592
        r->out.unknown3 = talloc_zero(r, uint32_t);
 
1593
        if (r->out.unknown3 == NULL) {
 
1594
                talloc_free(r);
 
1595
                return false;
 
1596
        }
 
1597
 
 
1598
        r->out.iface2 = talloc_zero(r, struct MInterfacePointer);
 
1599
        if (r->out.iface2 == NULL) {
 
1600
                talloc_free(r);
 
1601
                return false;
 
1602
        }
 
1603
 
 
1604
        r->out.result = _ISystemActivatorRemoteCreateInstance(p, r);
 
1605
 
 
1606
        if (p->rng_fault_state) {
 
1607
                talloc_free(r);
 
1608
                /* Return true here, srv_pipe_hnd.c will take care */
 
1609
                return true;
 
1610
        }
 
1611
 
 
1612
        if (DEBUGLEVEL >= 10) {
 
1613
                NDR_PRINT_FUNCTION_DEBUG(ISystemActivatorRemoteCreateInstance, NDR_OUT | NDR_SET_VALUES, r);
 
1614
        }
 
1615
 
 
1616
        push = ndr_push_init_ctx(r);
 
1617
        if (push == NULL) {
 
1618
                talloc_free(r);
 
1619
                return false;
 
1620
        }
 
1621
 
 
1622
        /*
 
1623
         * carry over the pointer count to the reply in case we are
 
1624
         * using full pointer. See NDR specification for full pointers
 
1625
         */
 
1626
        push->ptr_count = pull->ptr_count;
 
1627
 
 
1628
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1629
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1630
                talloc_free(r);
 
1631
                return false;
 
1632
        }
 
1633
 
 
1634
        p->out_data.rdata = ndr_push_blob(push);
 
1635
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1636
 
 
1637
        talloc_free(r);
 
1638
 
 
1639
        return true;
 
1640
}
 
1641
 
 
1642
 
 
1643
/* Tables */
 
1644
static struct api_struct api_ISystemActivator_cmds[] = 
 
1645
{
 
1646
        {"ISYSTEMACTIVATORREMOTECREATEINSTANCE", NDR_ISYSTEMACTIVATORREMOTECREATEINSTANCE, api_ISystemActivatorRemoteCreateInstance},
 
1647
};
 
1648
 
 
1649
void ISystemActivator_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1650
{
 
1651
        *fns = api_ISystemActivator_cmds;
 
1652
        *n_fns = sizeof(api_ISystemActivator_cmds) / sizeof(struct api_struct);
 
1653
}
 
1654
 
 
1655
NTSTATUS rpc_ISystemActivator_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1656
{
 
1657
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ISystemActivator", "ISystemActivator", &ndr_table_ISystemActivator, api_ISystemActivator_cmds, sizeof(api_ISystemActivator_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1658
}
 
1659
 
 
1660
NTSTATUS rpc_ISystemActivator_shutdown(void)
 
1661
{
 
1662
        return rpc_srv_unregister(&ndr_table_ISystemActivator);
 
1663
}
 
1664
static bool api_RemQueryInterface2(struct pipes_struct *p)
 
1665
{
 
1666
        const struct ndr_interface_call *call;
 
1667
        struct ndr_pull *pull;
 
1668
        struct ndr_push *push;
 
1669
        enum ndr_err_code ndr_err;
 
1670
        struct RemQueryInterface2 *r;
 
1671
 
 
1672
        call = &ndr_table_IRemUnknown2.calls[NDR_REMQUERYINTERFACE2];
 
1673
 
 
1674
        r = talloc(talloc_tos(), struct RemQueryInterface2);
 
1675
        if (r == NULL) {
 
1676
                return false;
 
1677
        }
 
1678
 
 
1679
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1680
        if (pull == NULL) {
 
1681
                talloc_free(r);
 
1682
                return false;
 
1683
        }
 
1684
 
 
1685
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1686
        if (p->endian) {
 
1687
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1688
        }
 
1689
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1690
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1691
                talloc_free(r);
 
1692
                return false;
 
1693
        }
 
1694
 
 
1695
        if (DEBUGLEVEL >= 10) {
 
1696
                NDR_PRINT_FUNCTION_DEBUG(RemQueryInterface2, NDR_IN, r);
 
1697
        }
 
1698
 
 
1699
        ZERO_STRUCT(r->out);
 
1700
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1701
        if (r->out.ORPCthat == NULL) {
 
1702
                talloc_free(r);
 
1703
                return false;
 
1704
        }
 
1705
 
 
1706
        r->out.phr = talloc_zero_array(r, WERROR, r->in.cIids);
 
1707
        if (r->out.phr == NULL) {
 
1708
                talloc_free(r);
 
1709
                return false;
 
1710
        }
 
1711
 
 
1712
        r->out.ppMIF = talloc_zero_array(r, struct MInterfacePointer, r->in.cIids);
 
1713
        if (r->out.ppMIF == NULL) {
 
1714
                talloc_free(r);
 
1715
                return false;
 
1716
        }
 
1717
 
 
1718
        r->out.result = _RemQueryInterface2(p, r);
 
1719
 
 
1720
        if (p->rng_fault_state) {
 
1721
                talloc_free(r);
 
1722
                /* Return true here, srv_pipe_hnd.c will take care */
 
1723
                return true;
 
1724
        }
 
1725
 
 
1726
        if (DEBUGLEVEL >= 10) {
 
1727
                NDR_PRINT_FUNCTION_DEBUG(RemQueryInterface2, NDR_OUT | NDR_SET_VALUES, r);
 
1728
        }
 
1729
 
 
1730
        push = ndr_push_init_ctx(r);
 
1731
        if (push == NULL) {
 
1732
                talloc_free(r);
 
1733
                return false;
 
1734
        }
 
1735
 
 
1736
        /*
 
1737
         * carry over the pointer count to the reply in case we are
 
1738
         * using full pointer. See NDR specification for full pointers
 
1739
         */
 
1740
        push->ptr_count = pull->ptr_count;
 
1741
 
 
1742
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1743
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1744
                talloc_free(r);
 
1745
                return false;
 
1746
        }
 
1747
 
 
1748
        p->out_data.rdata = ndr_push_blob(push);
 
1749
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1750
 
 
1751
        talloc_free(r);
 
1752
 
 
1753
        return true;
 
1754
}
 
1755
 
 
1756
 
 
1757
/* Tables */
 
1758
static struct api_struct api_IRemUnknown2_cmds[] = 
 
1759
{
 
1760
        {"REMQUERYINTERFACE2", NDR_REMQUERYINTERFACE2, api_RemQueryInterface2},
 
1761
};
 
1762
 
 
1763
void IRemUnknown2_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
1764
{
 
1765
        *fns = api_IRemUnknown2_cmds;
 
1766
        *n_fns = sizeof(api_IRemUnknown2_cmds) / sizeof(struct api_struct);
 
1767
}
 
1768
 
 
1769
NTSTATUS rpc_IRemUnknown2_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
1770
{
 
1771
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IRemUnknown2", "IRemUnknown2", &ndr_table_IRemUnknown2, api_IRemUnknown2_cmds, sizeof(api_IRemUnknown2_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
1772
}
 
1773
 
 
1774
NTSTATUS rpc_IRemUnknown2_shutdown(void)
 
1775
{
 
1776
        return rpc_srv_unregister(&ndr_table_IRemUnknown2);
 
1777
}
 
1778
static bool api_GetTypeInfoCount(struct pipes_struct *p)
 
1779
{
 
1780
        const struct ndr_interface_call *call;
 
1781
        struct ndr_pull *pull;
 
1782
        struct ndr_push *push;
 
1783
        enum ndr_err_code ndr_err;
 
1784
        struct GetTypeInfoCount *r;
 
1785
 
 
1786
        call = &ndr_table_IDispatch.calls[NDR_GETTYPEINFOCOUNT];
 
1787
 
 
1788
        r = talloc(talloc_tos(), struct GetTypeInfoCount);
 
1789
        if (r == NULL) {
 
1790
                return false;
 
1791
        }
 
1792
 
 
1793
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1794
        if (pull == NULL) {
 
1795
                talloc_free(r);
 
1796
                return false;
 
1797
        }
 
1798
 
 
1799
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1800
        if (p->endian) {
 
1801
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1802
        }
 
1803
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1804
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1805
                talloc_free(r);
 
1806
                return false;
 
1807
        }
 
1808
 
 
1809
        if (DEBUGLEVEL >= 10) {
 
1810
                NDR_PRINT_FUNCTION_DEBUG(GetTypeInfoCount, NDR_IN, r);
 
1811
        }
 
1812
 
 
1813
        ZERO_STRUCT(r->out);
 
1814
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1815
        if (r->out.ORPCthat == NULL) {
 
1816
                talloc_free(r);
 
1817
                return false;
 
1818
        }
 
1819
 
 
1820
        r->out.pctinfo = talloc_zero(r, uint16_t);
 
1821
        if (r->out.pctinfo == NULL) {
 
1822
                talloc_free(r);
 
1823
                return false;
 
1824
        }
 
1825
 
 
1826
        r->out.result = _GetTypeInfoCount(p, r);
 
1827
 
 
1828
        if (p->rng_fault_state) {
 
1829
                talloc_free(r);
 
1830
                /* Return true here, srv_pipe_hnd.c will take care */
 
1831
                return true;
 
1832
        }
 
1833
 
 
1834
        if (DEBUGLEVEL >= 10) {
 
1835
                NDR_PRINT_FUNCTION_DEBUG(GetTypeInfoCount, NDR_OUT | NDR_SET_VALUES, r);
 
1836
        }
 
1837
 
 
1838
        push = ndr_push_init_ctx(r);
 
1839
        if (push == NULL) {
 
1840
                talloc_free(r);
 
1841
                return false;
 
1842
        }
 
1843
 
 
1844
        /*
 
1845
         * carry over the pointer count to the reply in case we are
 
1846
         * using full pointer. See NDR specification for full pointers
 
1847
         */
 
1848
        push->ptr_count = pull->ptr_count;
 
1849
 
 
1850
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1851
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1852
                talloc_free(r);
 
1853
                return false;
 
1854
        }
 
1855
 
 
1856
        p->out_data.rdata = ndr_push_blob(push);
 
1857
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1858
 
 
1859
        talloc_free(r);
 
1860
 
 
1861
        return true;
 
1862
}
 
1863
 
 
1864
static bool api_GetTypeInfo(struct pipes_struct *p)
 
1865
{
 
1866
        const struct ndr_interface_call *call;
 
1867
        struct ndr_pull *pull;
 
1868
        struct ndr_push *push;
 
1869
        enum ndr_err_code ndr_err;
 
1870
        struct GetTypeInfo *r;
 
1871
 
 
1872
        call = &ndr_table_IDispatch.calls[NDR_GETTYPEINFO];
 
1873
 
 
1874
        r = talloc(talloc_tos(), struct GetTypeInfo);
 
1875
        if (r == NULL) {
 
1876
                return false;
 
1877
        }
 
1878
 
 
1879
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1880
        if (pull == NULL) {
 
1881
                talloc_free(r);
 
1882
                return false;
 
1883
        }
 
1884
 
 
1885
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1886
        if (p->endian) {
 
1887
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1888
        }
 
1889
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1890
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1891
                talloc_free(r);
 
1892
                return false;
 
1893
        }
 
1894
 
 
1895
        if (DEBUGLEVEL >= 10) {
 
1896
                NDR_PRINT_FUNCTION_DEBUG(GetTypeInfo, NDR_IN, r);
 
1897
        }
 
1898
 
 
1899
        ZERO_STRUCT(r->out);
 
1900
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1901
        if (r->out.ORPCthat == NULL) {
 
1902
                talloc_free(r);
 
1903
                return false;
 
1904
        }
 
1905
 
 
1906
        r->out.ppTInfo = talloc_zero(r, struct REF_ITypeInfo);
 
1907
        if (r->out.ppTInfo == NULL) {
 
1908
                talloc_free(r);
 
1909
                return false;
 
1910
        }
 
1911
 
 
1912
        r->out.result = _GetTypeInfo(p, r);
 
1913
 
 
1914
        if (p->rng_fault_state) {
 
1915
                talloc_free(r);
 
1916
                /* Return true here, srv_pipe_hnd.c will take care */
 
1917
                return true;
 
1918
        }
 
1919
 
 
1920
        if (DEBUGLEVEL >= 10) {
 
1921
                NDR_PRINT_FUNCTION_DEBUG(GetTypeInfo, NDR_OUT | NDR_SET_VALUES, r);
 
1922
        }
 
1923
 
 
1924
        push = ndr_push_init_ctx(r);
 
1925
        if (push == NULL) {
 
1926
                talloc_free(r);
 
1927
                return false;
 
1928
        }
 
1929
 
 
1930
        /*
 
1931
         * carry over the pointer count to the reply in case we are
 
1932
         * using full pointer. See NDR specification for full pointers
 
1933
         */
 
1934
        push->ptr_count = pull->ptr_count;
 
1935
 
 
1936
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
1937
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1938
                talloc_free(r);
 
1939
                return false;
 
1940
        }
 
1941
 
 
1942
        p->out_data.rdata = ndr_push_blob(push);
 
1943
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
1944
 
 
1945
        talloc_free(r);
 
1946
 
 
1947
        return true;
 
1948
}
 
1949
 
 
1950
static bool api_GetIDsOfNames(struct pipes_struct *p)
 
1951
{
 
1952
        const struct ndr_interface_call *call;
 
1953
        struct ndr_pull *pull;
 
1954
        struct ndr_push *push;
 
1955
        enum ndr_err_code ndr_err;
 
1956
        struct GetIDsOfNames *r;
 
1957
 
 
1958
        call = &ndr_table_IDispatch.calls[NDR_GETIDSOFNAMES];
 
1959
 
 
1960
        r = talloc(talloc_tos(), struct GetIDsOfNames);
 
1961
        if (r == NULL) {
 
1962
                return false;
 
1963
        }
 
1964
 
 
1965
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
1966
        if (pull == NULL) {
 
1967
                talloc_free(r);
 
1968
                return false;
 
1969
        }
 
1970
 
 
1971
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
1972
        if (p->endian) {
 
1973
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
1974
        }
 
1975
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
1976
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
1977
                talloc_free(r);
 
1978
                return false;
 
1979
        }
 
1980
 
 
1981
        if (DEBUGLEVEL >= 10) {
 
1982
                NDR_PRINT_FUNCTION_DEBUG(GetIDsOfNames, NDR_IN, r);
 
1983
        }
 
1984
 
 
1985
        ZERO_STRUCT(r->out);
 
1986
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
1987
        if (r->out.ORPCthat == NULL) {
 
1988
                talloc_free(r);
 
1989
                return false;
 
1990
        }
 
1991
 
 
1992
        r->out.rgDispId = talloc_zero_array(r, uint32_t, r->in.cNames);
 
1993
        if (r->out.rgDispId == NULL) {
 
1994
                talloc_free(r);
 
1995
                return false;
 
1996
        }
 
1997
 
 
1998
        r->out.result = _GetIDsOfNames(p, r);
 
1999
 
 
2000
        if (p->rng_fault_state) {
 
2001
                talloc_free(r);
 
2002
                /* Return true here, srv_pipe_hnd.c will take care */
 
2003
                return true;
 
2004
        }
 
2005
 
 
2006
        if (DEBUGLEVEL >= 10) {
 
2007
                NDR_PRINT_FUNCTION_DEBUG(GetIDsOfNames, NDR_OUT | NDR_SET_VALUES, r);
 
2008
        }
 
2009
 
 
2010
        push = ndr_push_init_ctx(r);
 
2011
        if (push == NULL) {
 
2012
                talloc_free(r);
 
2013
                return false;
 
2014
        }
 
2015
 
 
2016
        /*
 
2017
         * carry over the pointer count to the reply in case we are
 
2018
         * using full pointer. See NDR specification for full pointers
 
2019
         */
 
2020
        push->ptr_count = pull->ptr_count;
 
2021
 
 
2022
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2023
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2024
                talloc_free(r);
 
2025
                return false;
 
2026
        }
 
2027
 
 
2028
        p->out_data.rdata = ndr_push_blob(push);
 
2029
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2030
 
 
2031
        talloc_free(r);
 
2032
 
 
2033
        return true;
 
2034
}
 
2035
 
 
2036
static bool api_Invoke(struct pipes_struct *p)
 
2037
{
 
2038
        const struct ndr_interface_call *call;
 
2039
        struct ndr_pull *pull;
 
2040
        struct ndr_push *push;
 
2041
        enum ndr_err_code ndr_err;
 
2042
        struct Invoke *r;
 
2043
 
 
2044
        call = &ndr_table_IDispatch.calls[NDR_INVOKE];
 
2045
 
 
2046
        r = talloc(talloc_tos(), struct Invoke);
 
2047
        if (r == NULL) {
 
2048
                return false;
 
2049
        }
 
2050
 
 
2051
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2052
        if (pull == NULL) {
 
2053
                talloc_free(r);
 
2054
                return false;
 
2055
        }
 
2056
 
 
2057
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2058
        if (p->endian) {
 
2059
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2060
        }
 
2061
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2062
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2063
                talloc_free(r);
 
2064
                return false;
 
2065
        }
 
2066
 
 
2067
        if (DEBUGLEVEL >= 10) {
 
2068
                NDR_PRINT_FUNCTION_DEBUG(Invoke, NDR_IN, r);
 
2069
        }
 
2070
 
 
2071
        ZERO_STRUCT(r->out);
 
2072
        r->out.pDispParams = r->in.pDispParams;
 
2073
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2074
        if (r->out.ORPCthat == NULL) {
 
2075
                talloc_free(r);
 
2076
                return false;
 
2077
        }
 
2078
 
 
2079
        r->out.pVarResult = talloc_zero(r, struct VARIANT);
 
2080
        if (r->out.pVarResult == NULL) {
 
2081
                talloc_free(r);
 
2082
                return false;
 
2083
        }
 
2084
 
 
2085
        r->out.pExcepInfo = talloc_zero(r, struct EXCEPINFO);
 
2086
        if (r->out.pExcepInfo == NULL) {
 
2087
                talloc_free(r);
 
2088
                return false;
 
2089
        }
 
2090
 
 
2091
        r->out.puArgErr = talloc_zero(r, uint16_t);
 
2092
        if (r->out.puArgErr == NULL) {
 
2093
                talloc_free(r);
 
2094
                return false;
 
2095
        }
 
2096
 
 
2097
        r->out.result = _Invoke(p, r);
 
2098
 
 
2099
        if (p->rng_fault_state) {
 
2100
                talloc_free(r);
 
2101
                /* Return true here, srv_pipe_hnd.c will take care */
 
2102
                return true;
 
2103
        }
 
2104
 
 
2105
        if (DEBUGLEVEL >= 10) {
 
2106
                NDR_PRINT_FUNCTION_DEBUG(Invoke, NDR_OUT | NDR_SET_VALUES, r);
 
2107
        }
 
2108
 
 
2109
        push = ndr_push_init_ctx(r);
 
2110
        if (push == NULL) {
 
2111
                talloc_free(r);
 
2112
                return false;
 
2113
        }
 
2114
 
 
2115
        /*
 
2116
         * carry over the pointer count to the reply in case we are
 
2117
         * using full pointer. See NDR specification for full pointers
 
2118
         */
 
2119
        push->ptr_count = pull->ptr_count;
 
2120
 
 
2121
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2122
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2123
                talloc_free(r);
 
2124
                return false;
 
2125
        }
 
2126
 
 
2127
        p->out_data.rdata = ndr_push_blob(push);
 
2128
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2129
 
 
2130
        talloc_free(r);
 
2131
 
 
2132
        return true;
 
2133
}
 
2134
 
 
2135
 
 
2136
/* Tables */
 
2137
static struct api_struct api_IDispatch_cmds[] = 
 
2138
{
 
2139
        {"GETTYPEINFOCOUNT", NDR_GETTYPEINFOCOUNT, api_GetTypeInfoCount},
 
2140
        {"GETTYPEINFO", NDR_GETTYPEINFO, api_GetTypeInfo},
 
2141
        {"GETIDSOFNAMES", NDR_GETIDSOFNAMES, api_GetIDsOfNames},
 
2142
        {"INVOKE", NDR_INVOKE, api_Invoke},
 
2143
};
 
2144
 
 
2145
void IDispatch_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
2146
{
 
2147
        *fns = api_IDispatch_cmds;
 
2148
        *n_fns = sizeof(api_IDispatch_cmds) / sizeof(struct api_struct);
 
2149
}
 
2150
 
 
2151
NTSTATUS rpc_IDispatch_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
2152
{
 
2153
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IDispatch", "IDispatch", &ndr_table_IDispatch, api_IDispatch_cmds, sizeof(api_IDispatch_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
2154
}
 
2155
 
 
2156
NTSTATUS rpc_IDispatch_shutdown(void)
 
2157
{
 
2158
        return rpc_srv_unregister(&ndr_table_IDispatch);
 
2159
}
 
2160
static bool api_MarshalInterface(struct pipes_struct *p)
 
2161
{
 
2162
        const struct ndr_interface_call *call;
 
2163
        struct ndr_pull *pull;
 
2164
        struct ndr_push *push;
 
2165
        enum ndr_err_code ndr_err;
 
2166
        struct MarshalInterface *r;
 
2167
 
 
2168
        call = &ndr_table_IMarshal.calls[NDR_MARSHALINTERFACE];
 
2169
 
 
2170
        r = talloc(talloc_tos(), struct MarshalInterface);
 
2171
        if (r == NULL) {
 
2172
                return false;
 
2173
        }
 
2174
 
 
2175
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2176
        if (pull == NULL) {
 
2177
                talloc_free(r);
 
2178
                return false;
 
2179
        }
 
2180
 
 
2181
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2182
        if (p->endian) {
 
2183
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2184
        }
 
2185
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2186
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2187
                talloc_free(r);
 
2188
                return false;
 
2189
        }
 
2190
 
 
2191
        if (DEBUGLEVEL >= 10) {
 
2192
                NDR_PRINT_FUNCTION_DEBUG(MarshalInterface, NDR_IN, r);
 
2193
        }
 
2194
 
 
2195
        ZERO_STRUCT(r->out);
 
2196
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2197
        if (r->out.ORPCthat == NULL) {
 
2198
                talloc_free(r);
 
2199
                return false;
 
2200
        }
 
2201
 
 
2202
        r->out.result = _MarshalInterface(p, r);
 
2203
 
 
2204
        if (p->rng_fault_state) {
 
2205
                talloc_free(r);
 
2206
                /* Return true here, srv_pipe_hnd.c will take care */
 
2207
                return true;
 
2208
        }
 
2209
 
 
2210
        if (DEBUGLEVEL >= 10) {
 
2211
                NDR_PRINT_FUNCTION_DEBUG(MarshalInterface, NDR_OUT | NDR_SET_VALUES, r);
 
2212
        }
 
2213
 
 
2214
        push = ndr_push_init_ctx(r);
 
2215
        if (push == NULL) {
 
2216
                talloc_free(r);
 
2217
                return false;
 
2218
        }
 
2219
 
 
2220
        /*
 
2221
         * carry over the pointer count to the reply in case we are
 
2222
         * using full pointer. See NDR specification for full pointers
 
2223
         */
 
2224
        push->ptr_count = pull->ptr_count;
 
2225
 
 
2226
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2227
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2228
                talloc_free(r);
 
2229
                return false;
 
2230
        }
 
2231
 
 
2232
        p->out_data.rdata = ndr_push_blob(push);
 
2233
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2234
 
 
2235
        talloc_free(r);
 
2236
 
 
2237
        return true;
 
2238
}
 
2239
 
 
2240
static bool api_UnMarshalInterface(struct pipes_struct *p)
 
2241
{
 
2242
        const struct ndr_interface_call *call;
 
2243
        struct ndr_pull *pull;
 
2244
        struct ndr_push *push;
 
2245
        enum ndr_err_code ndr_err;
 
2246
        struct UnMarshalInterface *r;
 
2247
 
 
2248
        call = &ndr_table_IMarshal.calls[NDR_UNMARSHALINTERFACE];
 
2249
 
 
2250
        r = talloc(talloc_tos(), struct UnMarshalInterface);
 
2251
        if (r == NULL) {
 
2252
                return false;
 
2253
        }
 
2254
 
 
2255
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2256
        if (pull == NULL) {
 
2257
                talloc_free(r);
 
2258
                return false;
 
2259
        }
 
2260
 
 
2261
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2262
        if (p->endian) {
 
2263
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2264
        }
 
2265
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2266
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2267
                talloc_free(r);
 
2268
                return false;
 
2269
        }
 
2270
 
 
2271
        if (DEBUGLEVEL >= 10) {
 
2272
                NDR_PRINT_FUNCTION_DEBUG(UnMarshalInterface, NDR_IN, r);
 
2273
        }
 
2274
 
 
2275
        ZERO_STRUCT(r->out);
 
2276
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2277
        if (r->out.ORPCthat == NULL) {
 
2278
                talloc_free(r);
 
2279
                return false;
 
2280
        }
 
2281
 
 
2282
        r->out.result = _UnMarshalInterface(p, r);
 
2283
 
 
2284
        if (p->rng_fault_state) {
 
2285
                talloc_free(r);
 
2286
                /* Return true here, srv_pipe_hnd.c will take care */
 
2287
                return true;
 
2288
        }
 
2289
 
 
2290
        if (DEBUGLEVEL >= 10) {
 
2291
                NDR_PRINT_FUNCTION_DEBUG(UnMarshalInterface, NDR_OUT | NDR_SET_VALUES, r);
 
2292
        }
 
2293
 
 
2294
        push = ndr_push_init_ctx(r);
 
2295
        if (push == NULL) {
 
2296
                talloc_free(r);
 
2297
                return false;
 
2298
        }
 
2299
 
 
2300
        /*
 
2301
         * carry over the pointer count to the reply in case we are
 
2302
         * using full pointer. See NDR specification for full pointers
 
2303
         */
 
2304
        push->ptr_count = pull->ptr_count;
 
2305
 
 
2306
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2307
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2308
                talloc_free(r);
 
2309
                return false;
 
2310
        }
 
2311
 
 
2312
        p->out_data.rdata = ndr_push_blob(push);
 
2313
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2314
 
 
2315
        talloc_free(r);
 
2316
 
 
2317
        return true;
 
2318
}
 
2319
 
 
2320
 
 
2321
/* Tables */
 
2322
static struct api_struct api_IMarshal_cmds[] = 
 
2323
{
 
2324
        {"MARSHALINTERFACE", NDR_MARSHALINTERFACE, api_MarshalInterface},
 
2325
        {"UNMARSHALINTERFACE", NDR_UNMARSHALINTERFACE, api_UnMarshalInterface},
 
2326
};
 
2327
 
 
2328
void IMarshal_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
2329
{
 
2330
        *fns = api_IMarshal_cmds;
 
2331
        *n_fns = sizeof(api_IMarshal_cmds) / sizeof(struct api_struct);
 
2332
}
 
2333
 
 
2334
NTSTATUS rpc_IMarshal_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
2335
{
 
2336
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IMarshal", "IMarshal", &ndr_table_IMarshal, api_IMarshal_cmds, sizeof(api_IMarshal_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
2337
}
 
2338
 
 
2339
NTSTATUS rpc_IMarshal_shutdown(void)
 
2340
{
 
2341
        return rpc_srv_unregister(&ndr_table_IMarshal);
 
2342
}
 
2343
static bool api_MakeCoffee(struct pipes_struct *p)
 
2344
{
 
2345
        const struct ndr_interface_call *call;
 
2346
        struct ndr_pull *pull;
 
2347
        struct ndr_push *push;
 
2348
        enum ndr_err_code ndr_err;
 
2349
        struct MakeCoffee *r;
 
2350
 
 
2351
        call = &ndr_table_ICoffeeMachine.calls[NDR_MAKECOFFEE];
 
2352
 
 
2353
        r = talloc(talloc_tos(), struct MakeCoffee);
 
2354
        if (r == NULL) {
 
2355
                return false;
 
2356
        }
 
2357
 
 
2358
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2359
        if (pull == NULL) {
 
2360
                talloc_free(r);
 
2361
                return false;
 
2362
        }
 
2363
 
 
2364
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2365
        if (p->endian) {
 
2366
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2367
        }
 
2368
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2369
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2370
                talloc_free(r);
 
2371
                return false;
 
2372
        }
 
2373
 
 
2374
        if (DEBUGLEVEL >= 10) {
 
2375
                NDR_PRINT_FUNCTION_DEBUG(MakeCoffee, NDR_IN, r);
 
2376
        }
 
2377
 
 
2378
        ZERO_STRUCT(r->out);
 
2379
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2380
        if (r->out.ORPCthat == NULL) {
 
2381
                talloc_free(r);
 
2382
                return false;
 
2383
        }
 
2384
 
 
2385
        r->out.result = _MakeCoffee(p, r);
 
2386
 
 
2387
        if (p->rng_fault_state) {
 
2388
                talloc_free(r);
 
2389
                /* Return true here, srv_pipe_hnd.c will take care */
 
2390
                return true;
 
2391
        }
 
2392
 
 
2393
        if (DEBUGLEVEL >= 10) {
 
2394
                NDR_PRINT_FUNCTION_DEBUG(MakeCoffee, NDR_OUT | NDR_SET_VALUES, r);
 
2395
        }
 
2396
 
 
2397
        push = ndr_push_init_ctx(r);
 
2398
        if (push == NULL) {
 
2399
                talloc_free(r);
 
2400
                return false;
 
2401
        }
 
2402
 
 
2403
        /*
 
2404
         * carry over the pointer count to the reply in case we are
 
2405
         * using full pointer. See NDR specification for full pointers
 
2406
         */
 
2407
        push->ptr_count = pull->ptr_count;
 
2408
 
 
2409
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2410
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2411
                talloc_free(r);
 
2412
                return false;
 
2413
        }
 
2414
 
 
2415
        p->out_data.rdata = ndr_push_blob(push);
 
2416
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2417
 
 
2418
        talloc_free(r);
 
2419
 
 
2420
        return true;
 
2421
}
 
2422
 
 
2423
 
 
2424
/* Tables */
 
2425
static struct api_struct api_ICoffeeMachine_cmds[] = 
 
2426
{
 
2427
        {"MAKECOFFEE", NDR_MAKECOFFEE, api_MakeCoffee},
 
2428
};
 
2429
 
 
2430
void ICoffeeMachine_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
2431
{
 
2432
        *fns = api_ICoffeeMachine_cmds;
 
2433
        *n_fns = sizeof(api_ICoffeeMachine_cmds) / sizeof(struct api_struct);
 
2434
}
 
2435
 
 
2436
NTSTATUS rpc_ICoffeeMachine_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
2437
{
 
2438
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ICoffeeMachine", "ICoffeeMachine", &ndr_table_ICoffeeMachine, api_ICoffeeMachine_cmds, sizeof(api_ICoffeeMachine_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
2439
}
 
2440
 
 
2441
NTSTATUS rpc_ICoffeeMachine_shutdown(void)
 
2442
{
 
2443
        return rpc_srv_unregister(&ndr_table_ICoffeeMachine);
 
2444
}
 
2445
static bool api_Read(struct pipes_struct *p)
 
2446
{
 
2447
        const struct ndr_interface_call *call;
 
2448
        struct ndr_pull *pull;
 
2449
        struct ndr_push *push;
 
2450
        enum ndr_err_code ndr_err;
 
2451
        struct Read *r;
 
2452
 
 
2453
        call = &ndr_table_IStream.calls[NDR_READ];
 
2454
 
 
2455
        r = talloc(talloc_tos(), struct Read);
 
2456
        if (r == NULL) {
 
2457
                return false;
 
2458
        }
 
2459
 
 
2460
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2461
        if (pull == NULL) {
 
2462
                talloc_free(r);
 
2463
                return false;
 
2464
        }
 
2465
 
 
2466
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2467
        if (p->endian) {
 
2468
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2469
        }
 
2470
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2471
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2472
                talloc_free(r);
 
2473
                return false;
 
2474
        }
 
2475
 
 
2476
        if (DEBUGLEVEL >= 10) {
 
2477
                NDR_PRINT_FUNCTION_DEBUG(Read, NDR_IN, r);
 
2478
        }
 
2479
 
 
2480
        ZERO_STRUCT(r->out);
 
2481
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2482
        if (r->out.ORPCthat == NULL) {
 
2483
                talloc_free(r);
 
2484
                return false;
 
2485
        }
 
2486
 
 
2487
        r->out.pv = talloc_zero_array(r, uint8_t, r->in.num_requested);
 
2488
        if (r->out.pv == NULL) {
 
2489
                talloc_free(r);
 
2490
                return false;
 
2491
        }
 
2492
 
 
2493
        r->out.num_read = talloc_zero(r, uint32_t);
 
2494
        if (r->out.num_read == NULL) {
 
2495
                talloc_free(r);
 
2496
                return false;
 
2497
        }
 
2498
 
 
2499
        r->out.result = _Read(p, r);
 
2500
 
 
2501
        if (p->rng_fault_state) {
 
2502
                talloc_free(r);
 
2503
                /* Return true here, srv_pipe_hnd.c will take care */
 
2504
                return true;
 
2505
        }
 
2506
 
 
2507
        if (DEBUGLEVEL >= 10) {
 
2508
                NDR_PRINT_FUNCTION_DEBUG(Read, NDR_OUT | NDR_SET_VALUES, r);
 
2509
        }
 
2510
 
 
2511
        push = ndr_push_init_ctx(r);
 
2512
        if (push == NULL) {
 
2513
                talloc_free(r);
 
2514
                return false;
 
2515
        }
 
2516
 
 
2517
        /*
 
2518
         * carry over the pointer count to the reply in case we are
 
2519
         * using full pointer. See NDR specification for full pointers
 
2520
         */
 
2521
        push->ptr_count = pull->ptr_count;
 
2522
 
 
2523
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2524
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2525
                talloc_free(r);
 
2526
                return false;
 
2527
        }
 
2528
 
 
2529
        p->out_data.rdata = ndr_push_blob(push);
 
2530
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2531
 
 
2532
        talloc_free(r);
 
2533
 
 
2534
        return true;
 
2535
}
 
2536
 
 
2537
static bool api_Write(struct pipes_struct *p)
 
2538
{
 
2539
        const struct ndr_interface_call *call;
 
2540
        struct ndr_pull *pull;
 
2541
        struct ndr_push *push;
 
2542
        enum ndr_err_code ndr_err;
 
2543
        struct Write *r;
 
2544
 
 
2545
        call = &ndr_table_IStream.calls[NDR_WRITE];
 
2546
 
 
2547
        r = talloc(talloc_tos(), struct Write);
 
2548
        if (r == NULL) {
 
2549
                return false;
 
2550
        }
 
2551
 
 
2552
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
2553
        if (pull == NULL) {
 
2554
                talloc_free(r);
 
2555
                return false;
 
2556
        }
 
2557
 
 
2558
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
2559
        if (p->endian) {
 
2560
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
2561
        }
 
2562
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
2563
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2564
                talloc_free(r);
 
2565
                return false;
 
2566
        }
 
2567
 
 
2568
        if (DEBUGLEVEL >= 10) {
 
2569
                NDR_PRINT_FUNCTION_DEBUG(Write, NDR_IN, r);
 
2570
        }
 
2571
 
 
2572
        ZERO_STRUCT(r->out);
 
2573
        r->out.ORPCthat = talloc_zero(r, struct ORPCTHAT);
 
2574
        if (r->out.ORPCthat == NULL) {
 
2575
                talloc_free(r);
 
2576
                return false;
 
2577
        }
 
2578
 
 
2579
        r->out.num_written = talloc_zero(r, uint32_t);
 
2580
        if (r->out.num_written == NULL) {
 
2581
                talloc_free(r);
 
2582
                return false;
 
2583
        }
 
2584
 
 
2585
        r->out.result = _Write(p, r);
 
2586
 
 
2587
        if (p->rng_fault_state) {
 
2588
                talloc_free(r);
 
2589
                /* Return true here, srv_pipe_hnd.c will take care */
 
2590
                return true;
 
2591
        }
 
2592
 
 
2593
        if (DEBUGLEVEL >= 10) {
 
2594
                NDR_PRINT_FUNCTION_DEBUG(Write, NDR_OUT | NDR_SET_VALUES, r);
 
2595
        }
 
2596
 
 
2597
        push = ndr_push_init_ctx(r);
 
2598
        if (push == NULL) {
 
2599
                talloc_free(r);
 
2600
                return false;
 
2601
        }
 
2602
 
 
2603
        /*
 
2604
         * carry over the pointer count to the reply in case we are
 
2605
         * using full pointer. See NDR specification for full pointers
 
2606
         */
 
2607
        push->ptr_count = pull->ptr_count;
 
2608
 
 
2609
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
2610
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
2611
                talloc_free(r);
 
2612
                return false;
 
2613
        }
 
2614
 
 
2615
        p->out_data.rdata = ndr_push_blob(push);
 
2616
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
2617
 
 
2618
        talloc_free(r);
 
2619
 
 
2620
        return true;
 
2621
}
 
2622
 
 
2623
 
 
2624
/* Tables */
 
2625
static struct api_struct api_IStream_cmds[] = 
 
2626
{
 
2627
        {"READ", NDR_READ, api_Read},
 
2628
        {"WRITE", NDR_WRITE, api_Write},
 
2629
};
 
2630
 
 
2631
void IStream_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
2632
{
 
2633
        *fns = api_IStream_cmds;
 
2634
        *n_fns = sizeof(api_IStream_cmds) / sizeof(struct api_struct);
 
2635
}
 
2636
 
 
2637
NTSTATUS rpc_IStream_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
2638
{
 
2639
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IStream", "IStream", &ndr_table_IStream, api_IStream_cmds, sizeof(api_IStream_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
2640
}
 
2641
 
 
2642
NTSTATUS rpc_IStream_shutdown(void)
 
2643
{
 
2644
        return rpc_srv_unregister(&ndr_table_IStream);
 
2645
}