← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/srv_oxidresolver.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_oxidresolver.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_oxidresolver.h"
 
9
 
 
10
static bool api_ResolveOxid(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 ResolveOxid *r;
 
17
 
 
18
        call = &ndr_table_IOXIDResolver.calls[NDR_RESOLVEOXID];
 
19
 
 
20
        r = talloc(talloc_tos(), struct ResolveOxid);
 
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(ResolveOxid, NDR_IN, r);
 
43
        }
 
44
 
 
45
        ZERO_STRUCT(r->out);
 
46
        r->out.ppdsaOxidBindings = talloc_zero(r, struct DUALSTRINGARRAY *);
 
47
        if (r->out.ppdsaOxidBindings == NULL) {
 
48
                talloc_free(r);
 
49
                return false;
 
50
        }
 
51
 
 
52
        r->out.pipidRemUnknown = talloc_zero(r, struct GUID);
 
53
        if (r->out.pipidRemUnknown == NULL) {
 
54
                talloc_free(r);
 
55
                return false;
 
56
        }
 
57
 
 
58
        r->out.pAuthnHint = talloc_zero(r, uint32_t);
 
59
        if (r->out.pAuthnHint == NULL) {
 
60
                talloc_free(r);
 
61
                return false;
 
62
        }
 
63
 
 
64
        r->out.result = _ResolveOxid(p, r);
 
65
 
 
66
        if (p->rng_fault_state) {
 
67
                talloc_free(r);
 
68
                /* Return true here, srv_pipe_hnd.c will take care */
 
69
                return true;
 
70
        }
 
71
 
 
72
        if (DEBUGLEVEL >= 10) {
 
73
                NDR_PRINT_FUNCTION_DEBUG(ResolveOxid, NDR_OUT | NDR_SET_VALUES, r);
 
74
        }
 
75
 
 
76
        push = ndr_push_init_ctx(r);
 
77
        if (push == NULL) {
 
78
                talloc_free(r);
 
79
                return false;
 
80
        }
 
81
 
 
82
        /*
 
83
         * carry over the pointer count to the reply in case we are
 
84
         * using full pointer. See NDR specification for full pointers
 
85
         */
 
86
        push->ptr_count = pull->ptr_count;
 
87
 
 
88
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
89
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
90
                talloc_free(r);
 
91
                return false;
 
92
        }
 
93
 
 
94
        p->out_data.rdata = ndr_push_blob(push);
 
95
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
96
 
 
97
        talloc_free(r);
 
98
 
 
99
        return true;
 
100
}
 
101
 
 
102
static bool api_SimplePing(struct pipes_struct *p)
 
103
{
 
104
        const struct ndr_interface_call *call;
 
105
        struct ndr_pull *pull;
 
106
        struct ndr_push *push;
 
107
        enum ndr_err_code ndr_err;
 
108
        struct SimplePing *r;
 
109
 
 
110
        call = &ndr_table_IOXIDResolver.calls[NDR_SIMPLEPING];
 
111
 
 
112
        r = talloc(talloc_tos(), struct SimplePing);
 
113
        if (r == NULL) {
 
114
                return false;
 
115
        }
 
116
 
 
117
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
118
        if (pull == NULL) {
 
119
                talloc_free(r);
 
120
                return false;
 
121
        }
 
122
 
 
123
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
124
        if (p->endian) {
 
125
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
126
        }
 
127
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
128
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
129
                talloc_free(r);
 
130
                return false;
 
131
        }
 
132
 
 
133
        if (DEBUGLEVEL >= 10) {
 
134
                NDR_PRINT_FUNCTION_DEBUG(SimplePing, NDR_IN, r);
 
135
        }
 
136
 
 
137
        r->out.result = _SimplePing(p, r);
 
138
 
 
139
        if (p->rng_fault_state) {
 
140
                talloc_free(r);
 
141
                /* Return true here, srv_pipe_hnd.c will take care */
 
142
                return true;
 
143
        }
 
144
 
 
145
        if (DEBUGLEVEL >= 10) {
 
146
                NDR_PRINT_FUNCTION_DEBUG(SimplePing, NDR_OUT | NDR_SET_VALUES, r);
 
147
        }
 
148
 
 
149
        push = ndr_push_init_ctx(r);
 
150
        if (push == NULL) {
 
151
                talloc_free(r);
 
152
                return false;
 
153
        }
 
154
 
 
155
        /*
 
156
         * carry over the pointer count to the reply in case we are
 
157
         * using full pointer. See NDR specification for full pointers
 
158
         */
 
159
        push->ptr_count = pull->ptr_count;
 
160
 
 
161
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
162
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
163
                talloc_free(r);
 
164
                return false;
 
165
        }
 
166
 
 
167
        p->out_data.rdata = ndr_push_blob(push);
 
168
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
169
 
 
170
        talloc_free(r);
 
171
 
 
172
        return true;
 
173
}
 
174
 
 
175
static bool api_ComplexPing(struct pipes_struct *p)
 
176
{
 
177
        const struct ndr_interface_call *call;
 
178
        struct ndr_pull *pull;
 
179
        struct ndr_push *push;
 
180
        enum ndr_err_code ndr_err;
 
181
        struct ComplexPing *r;
 
182
 
 
183
        call = &ndr_table_IOXIDResolver.calls[NDR_COMPLEXPING];
 
184
 
 
185
        r = talloc(talloc_tos(), struct ComplexPing);
 
186
        if (r == NULL) {
 
187
                return false;
 
188
        }
 
189
 
 
190
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
191
        if (pull == NULL) {
 
192
                talloc_free(r);
 
193
                return false;
 
194
        }
 
195
 
 
196
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
197
        if (p->endian) {
 
198
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
199
        }
 
200
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
201
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
202
                talloc_free(r);
 
203
                return false;
 
204
        }
 
205
 
 
206
        if (DEBUGLEVEL >= 10) {
 
207
                NDR_PRINT_FUNCTION_DEBUG(ComplexPing, NDR_IN, r);
 
208
        }
 
209
 
 
210
        ZERO_STRUCT(r->out);
 
211
        r->out.SetId = r->in.SetId;
 
212
        r->out.PingBackoffFactor = talloc_zero(r, uint16_t);
 
213
        if (r->out.PingBackoffFactor == NULL) {
 
214
                talloc_free(r);
 
215
                return false;
 
216
        }
 
217
 
 
218
        r->out.result = _ComplexPing(p, r);
 
219
 
 
220
        if (p->rng_fault_state) {
 
221
                talloc_free(r);
 
222
                /* Return true here, srv_pipe_hnd.c will take care */
 
223
                return true;
 
224
        }
 
225
 
 
226
        if (DEBUGLEVEL >= 10) {
 
227
                NDR_PRINT_FUNCTION_DEBUG(ComplexPing, NDR_OUT | NDR_SET_VALUES, r);
 
228
        }
 
229
 
 
230
        push = ndr_push_init_ctx(r);
 
231
        if (push == NULL) {
 
232
                talloc_free(r);
 
233
                return false;
 
234
        }
 
235
 
 
236
        /*
 
237
         * carry over the pointer count to the reply in case we are
 
238
         * using full pointer. See NDR specification for full pointers
 
239
         */
 
240
        push->ptr_count = pull->ptr_count;
 
241
 
 
242
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
243
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
244
                talloc_free(r);
 
245
                return false;
 
246
        }
 
247
 
 
248
        p->out_data.rdata = ndr_push_blob(push);
 
249
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
250
 
 
251
        talloc_free(r);
 
252
 
 
253
        return true;
 
254
}
 
255
 
 
256
static bool api_ServerAlive(struct pipes_struct *p)
 
257
{
 
258
        const struct ndr_interface_call *call;
 
259
        struct ndr_pull *pull;
 
260
        struct ndr_push *push;
 
261
        enum ndr_err_code ndr_err;
 
262
        struct ServerAlive *r;
 
263
 
 
264
        call = &ndr_table_IOXIDResolver.calls[NDR_SERVERALIVE];
 
265
 
 
266
        r = talloc(talloc_tos(), struct ServerAlive);
 
267
        if (r == NULL) {
 
268
                return false;
 
269
        }
 
270
 
 
271
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
272
        if (pull == NULL) {
 
273
                talloc_free(r);
 
274
                return false;
 
275
        }
 
276
 
 
277
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
278
        if (p->endian) {
 
279
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
280
        }
 
281
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
282
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
283
                talloc_free(r);
 
284
                return false;
 
285
        }
 
286
 
 
287
        if (DEBUGLEVEL >= 10) {
 
288
                NDR_PRINT_FUNCTION_DEBUG(ServerAlive, NDR_IN, r);
 
289
        }
 
290
 
 
291
        r->out.result = _ServerAlive(p, r);
 
292
 
 
293
        if (p->rng_fault_state) {
 
294
                talloc_free(r);
 
295
                /* Return true here, srv_pipe_hnd.c will take care */
 
296
                return true;
 
297
        }
 
298
 
 
299
        if (DEBUGLEVEL >= 10) {
 
300
                NDR_PRINT_FUNCTION_DEBUG(ServerAlive, NDR_OUT | NDR_SET_VALUES, r);
 
301
        }
 
302
 
 
303
        push = ndr_push_init_ctx(r);
 
304
        if (push == NULL) {
 
305
                talloc_free(r);
 
306
                return false;
 
307
        }
 
308
 
 
309
        /*
 
310
         * carry over the pointer count to the reply in case we are
 
311
         * using full pointer. See NDR specification for full pointers
 
312
         */
 
313
        push->ptr_count = pull->ptr_count;
 
314
 
 
315
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
316
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
317
                talloc_free(r);
 
318
                return false;
 
319
        }
 
320
 
 
321
        p->out_data.rdata = ndr_push_blob(push);
 
322
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
323
 
 
324
        talloc_free(r);
 
325
 
 
326
        return true;
 
327
}
 
328
 
 
329
static bool api_ResolveOxid2(struct pipes_struct *p)
 
330
{
 
331
        const struct ndr_interface_call *call;
 
332
        struct ndr_pull *pull;
 
333
        struct ndr_push *push;
 
334
        enum ndr_err_code ndr_err;
 
335
        struct ResolveOxid2 *r;
 
336
 
 
337
        call = &ndr_table_IOXIDResolver.calls[NDR_RESOLVEOXID2];
 
338
 
 
339
        r = talloc(talloc_tos(), struct ResolveOxid2);
 
340
        if (r == NULL) {
 
341
                return false;
 
342
        }
 
343
 
 
344
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
345
        if (pull == NULL) {
 
346
                talloc_free(r);
 
347
                return false;
 
348
        }
 
349
 
 
350
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
351
        if (p->endian) {
 
352
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
353
        }
 
354
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
355
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
356
                talloc_free(r);
 
357
                return false;
 
358
        }
 
359
 
 
360
        if (DEBUGLEVEL >= 10) {
 
361
                NDR_PRINT_FUNCTION_DEBUG(ResolveOxid2, NDR_IN, r);
 
362
        }
 
363
 
 
364
        ZERO_STRUCT(r->out);
 
365
        r->out.pdsaOxidBindings = talloc_zero(r, struct DUALSTRINGARRAY *);
 
366
        if (r->out.pdsaOxidBindings == NULL) {
 
367
                talloc_free(r);
 
368
                return false;
 
369
        }
 
370
 
 
371
        r->out.ipidRemUnknown = talloc_zero(r, struct GUID);
 
372
        if (r->out.ipidRemUnknown == NULL) {
 
373
                talloc_free(r);
 
374
                return false;
 
375
        }
 
376
 
 
377
        r->out.AuthnHint = talloc_zero(r, uint32_t);
 
378
        if (r->out.AuthnHint == NULL) {
 
379
                talloc_free(r);
 
380
                return false;
 
381
        }
 
382
 
 
383
        r->out.ComVersion = talloc_zero(r, struct COMVERSION);
 
384
        if (r->out.ComVersion == NULL) {
 
385
                talloc_free(r);
 
386
                return false;
 
387
        }
 
388
 
 
389
        r->out.result = _ResolveOxid2(p, r);
 
390
 
 
391
        if (p->rng_fault_state) {
 
392
                talloc_free(r);
 
393
                /* Return true here, srv_pipe_hnd.c will take care */
 
394
                return true;
 
395
        }
 
396
 
 
397
        if (DEBUGLEVEL >= 10) {
 
398
                NDR_PRINT_FUNCTION_DEBUG(ResolveOxid2, NDR_OUT | NDR_SET_VALUES, r);
 
399
        }
 
400
 
 
401
        push = ndr_push_init_ctx(r);
 
402
        if (push == NULL) {
 
403
                talloc_free(r);
 
404
                return false;
 
405
        }
 
406
 
 
407
        /*
 
408
         * carry over the pointer count to the reply in case we are
 
409
         * using full pointer. See NDR specification for full pointers
 
410
         */
 
411
        push->ptr_count = pull->ptr_count;
 
412
 
 
413
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
414
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
415
                talloc_free(r);
 
416
                return false;
 
417
        }
 
418
 
 
419
        p->out_data.rdata = ndr_push_blob(push);
 
420
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
421
 
 
422
        talloc_free(r);
 
423
 
 
424
        return true;
 
425
}
 
426
 
 
427
static bool api_ServerAlive2(struct pipes_struct *p)
 
428
{
 
429
        const struct ndr_interface_call *call;
 
430
        struct ndr_pull *pull;
 
431
        struct ndr_push *push;
 
432
        enum ndr_err_code ndr_err;
 
433
        struct ServerAlive2 *r;
 
434
 
 
435
        call = &ndr_table_IOXIDResolver.calls[NDR_SERVERALIVE2];
 
436
 
 
437
        r = talloc(talloc_tos(), struct ServerAlive2);
 
438
        if (r == NULL) {
 
439
                return false;
 
440
        }
 
441
 
 
442
        pull = ndr_pull_init_blob(&p->in_data.data, r);
 
443
        if (pull == NULL) {
 
444
                talloc_free(r);
 
445
                return false;
 
446
        }
 
447
 
 
448
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
449
        if (p->endian) {
 
450
                pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 
451
        }
 
452
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
 
453
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
454
                talloc_free(r);
 
455
                return false;
 
456
        }
 
457
 
 
458
        if (DEBUGLEVEL >= 10) {
 
459
                NDR_PRINT_FUNCTION_DEBUG(ServerAlive2, NDR_IN, r);
 
460
        }
 
461
 
 
462
        ZERO_STRUCT(r->out);
 
463
        r->out.info = talloc_zero(r, struct COMINFO);
 
464
        if (r->out.info == NULL) {
 
465
                talloc_free(r);
 
466
                return false;
 
467
        }
 
468
 
 
469
        r->out.dualstring = talloc_zero(r, struct DUALSTRINGARRAY);
 
470
        if (r->out.dualstring == NULL) {
 
471
                talloc_free(r);
 
472
                return false;
 
473
        }
 
474
 
 
475
        r->out.unknown2 = talloc_zero(r, uint8_t);
 
476
        if (r->out.unknown2 == NULL) {
 
477
                talloc_free(r);
 
478
                return false;
 
479
        }
 
480
 
 
481
        r->out.unknown3 = talloc_zero(r, uint8_t);
 
482
        if (r->out.unknown3 == NULL) {
 
483
                talloc_free(r);
 
484
                return false;
 
485
        }
 
486
 
 
487
        r->out.unknown4 = talloc_zero(r, uint8_t);
 
488
        if (r->out.unknown4 == NULL) {
 
489
                talloc_free(r);
 
490
                return false;
 
491
        }
 
492
 
 
493
        r->out.result = _ServerAlive2(p, r);
 
494
 
 
495
        if (p->rng_fault_state) {
 
496
                talloc_free(r);
 
497
                /* Return true here, srv_pipe_hnd.c will take care */
 
498
                return true;
 
499
        }
 
500
 
 
501
        if (DEBUGLEVEL >= 10) {
 
502
                NDR_PRINT_FUNCTION_DEBUG(ServerAlive2, NDR_OUT | NDR_SET_VALUES, r);
 
503
        }
 
504
 
 
505
        push = ndr_push_init_ctx(r);
 
506
        if (push == NULL) {
 
507
                talloc_free(r);
 
508
                return false;
 
509
        }
 
510
 
 
511
        /*
 
512
         * carry over the pointer count to the reply in case we are
 
513
         * using full pointer. See NDR specification for full pointers
 
514
         */
 
515
        push->ptr_count = pull->ptr_count;
 
516
 
 
517
        ndr_err = call->ndr_push(push, NDR_OUT, r);
 
518
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
519
                talloc_free(r);
 
520
                return false;
 
521
        }
 
522
 
 
523
        p->out_data.rdata = ndr_push_blob(push);
 
524
        talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 
525
 
 
526
        talloc_free(r);
 
527
 
 
528
        return true;
 
529
}
 
530
 
 
531
 
 
532
/* Tables */
 
533
static struct api_struct api_IOXIDResolver_cmds[] = 
 
534
{
 
535
        {"RESOLVEOXID", NDR_RESOLVEOXID, api_ResolveOxid},
 
536
        {"SIMPLEPING", NDR_SIMPLEPING, api_SimplePing},
 
537
        {"COMPLEXPING", NDR_COMPLEXPING, api_ComplexPing},
 
538
        {"SERVERALIVE", NDR_SERVERALIVE, api_ServerAlive},
 
539
        {"RESOLVEOXID2", NDR_RESOLVEOXID2, api_ResolveOxid2},
 
540
        {"SERVERALIVE2", NDR_SERVERALIVE2, api_ServerAlive2},
 
541
};
 
542
 
 
543
void IOXIDResolver_get_pipe_fns(struct api_struct **fns, int *n_fns)
 
544
{
 
545
        *fns = api_IOXIDResolver_cmds;
 
546
        *n_fns = sizeof(api_IOXIDResolver_cmds) / sizeof(struct api_struct);
 
547
}
 
548
 
 
549
NTSTATUS rpc_IOXIDResolver_init(const struct rpc_srv_callbacks *rpc_srv_cb)
 
550
{
 
551
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "IOXIDResolver", "IOXIDResolver", &ndr_table_IOXIDResolver, api_IOXIDResolver_cmds, sizeof(api_IOXIDResolver_cmds) / sizeof(struct api_struct), rpc_srv_cb);
 
552
}
 
553
 
 
554
NTSTATUS rpc_IOXIDResolver_shutdown(void)
 
555
{
 
556
        return rpc_srv_unregister(&ndr_table_IOXIDResolver);
 
557
}