← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_dssetup.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_dssetup.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_dssetup.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
static enum ndr_err_code ndr_push_dssetup_DsRole(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRole r)
 
8
{
 
9
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
10
        return NDR_ERR_SUCCESS;
 
11
}
 
12
 
 
13
static enum ndr_err_code ndr_pull_dssetup_DsRole(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRole *r)
 
14
{
 
15
        uint16_t v;
 
16
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
17
        *r = v;
 
18
        return NDR_ERR_SUCCESS;
 
19
}
 
20
 
 
21
_PUBLIC_ void ndr_print_dssetup_DsRole(struct ndr_print *ndr, const char *name, enum dssetup_DsRole r)
 
22
{
 
23
        const char *val = NULL;
 
24
 
 
25
        switch (r) {
 
26
                case DS_ROLE_STANDALONE_WORKSTATION: val = "DS_ROLE_STANDALONE_WORKSTATION"; break;
 
27
                case DS_ROLE_MEMBER_WORKSTATION: val = "DS_ROLE_MEMBER_WORKSTATION"; break;
 
28
                case DS_ROLE_STANDALONE_SERVER: val = "DS_ROLE_STANDALONE_SERVER"; break;
 
29
                case DS_ROLE_MEMBER_SERVER: val = "DS_ROLE_MEMBER_SERVER"; break;
 
30
                case DS_ROLE_BACKUP_DC: val = "DS_ROLE_BACKUP_DC"; break;
 
31
                case DS_ROLE_PRIMARY_DC: val = "DS_ROLE_PRIMARY_DC"; break;
 
32
        }
 
33
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
34
}
 
35
 
 
36
static enum ndr_err_code ndr_push_dssetup_DsRoleFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
37
{
 
38
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
39
        return NDR_ERR_SUCCESS;
 
40
}
 
41
 
 
42
static enum ndr_err_code ndr_pull_dssetup_DsRoleFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
43
{
 
44
        uint32_t v;
 
45
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
46
        *r = v;
 
47
        return NDR_ERR_SUCCESS;
 
48
}
 
49
 
 
50
_PUBLIC_ void ndr_print_dssetup_DsRoleFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 
51
{
 
52
        ndr_print_uint32(ndr, name, r);
 
53
        ndr->depth++;
 
54
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DS_RUNNING", DS_ROLE_PRIMARY_DS_RUNNING, r);
 
55
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DS_MIXED_MODE", DS_ROLE_PRIMARY_DS_MIXED_MODE, r);
 
56
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_UPGRADE_IN_PROGRESS", DS_ROLE_UPGRADE_IN_PROGRESS, r);
 
57
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT", DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT, r);
 
58
        ndr->depth--;
 
59
}
 
60
 
 
61
static enum ndr_err_code ndr_push_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRolePrimaryDomInfoBasic *r)
 
62
{
 
63
        if (ndr_flags & NDR_SCALARS) {
 
64
                NDR_CHECK(ndr_push_align(ndr, 4));
 
65
                NDR_CHECK(ndr_push_dssetup_DsRole(ndr, NDR_SCALARS, r->role));
 
66
                NDR_CHECK(ndr_push_dssetup_DsRoleFlags(ndr, NDR_SCALARS, r->flags));
 
67
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
 
68
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain));
 
69
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->forest));
 
70
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
 
71
        }
 
72
        if (ndr_flags & NDR_BUFFERS) {
 
73
                if (r->domain) {
 
74
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
 
75
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
76
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
 
77
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
78
                }
 
79
                if (r->dns_domain) {
 
80
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain, CH_UTF16)));
 
81
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
82
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain, CH_UTF16)));
 
83
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_domain, ndr_charset_length(r->dns_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
84
                }
 
85
                if (r->forest) {
 
86
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->forest, CH_UTF16)));
 
87
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
88
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->forest, CH_UTF16)));
 
89
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->forest, ndr_charset_length(r->forest, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
90
                }
 
91
        }
 
92
        return NDR_ERR_SUCCESS;
 
93
}
 
94
 
 
95
static enum ndr_err_code ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRolePrimaryDomInfoBasic *r)
 
96
{
 
97
        uint32_t _ptr_domain;
 
98
        TALLOC_CTX *_mem_save_domain_0;
 
99
        uint32_t _ptr_dns_domain;
 
100
        TALLOC_CTX *_mem_save_dns_domain_0;
 
101
        uint32_t _ptr_forest;
 
102
        TALLOC_CTX *_mem_save_forest_0;
 
103
        if (ndr_flags & NDR_SCALARS) {
 
104
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
105
                NDR_CHECK(ndr_pull_dssetup_DsRole(ndr, NDR_SCALARS, &r->role));
 
106
                NDR_CHECK(ndr_pull_dssetup_DsRoleFlags(ndr, NDR_SCALARS, &r->flags));
 
107
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
 
108
                if (_ptr_domain) {
 
109
                        NDR_PULL_ALLOC(ndr, r->domain);
 
110
                } else {
 
111
                        r->domain = NULL;
 
112
                }
 
113
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain));
 
114
                if (_ptr_dns_domain) {
 
115
                        NDR_PULL_ALLOC(ndr, r->dns_domain);
 
116
                } else {
 
117
                        r->dns_domain = NULL;
 
118
                }
 
119
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest));
 
120
                if (_ptr_forest) {
 
121
                        NDR_PULL_ALLOC(ndr, r->forest);
 
122
                } else {
 
123
                        r->forest = NULL;
 
124
                }
 
125
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
 
126
        }
 
127
        if (ndr_flags & NDR_BUFFERS) {
 
128
                if (r->domain) {
 
129
                        _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
130
                        NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
 
131
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
 
132
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
 
133
                        if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
 
134
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));
 
135
                        }
 
136
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
 
137
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
 
138
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
 
139
                }
 
140
                if (r->dns_domain) {
 
141
                        _mem_save_dns_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
142
                        NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain, 0);
 
143
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain));
 
144
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain));
 
145
                        if (ndr_get_array_length(ndr, &r->dns_domain) > ndr_get_array_size(ndr, &r->dns_domain)) {
 
146
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_domain), ndr_get_array_length(ndr, &r->dns_domain));
 
147
                        }
 
148
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain), sizeof(uint16_t)));
 
149
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain, ndr_get_array_length(ndr, &r->dns_domain), sizeof(uint16_t), CH_UTF16));
 
150
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_0, 0);
 
151
                }
 
152
                if (r->forest) {
 
153
                        _mem_save_forest_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
154
                        NDR_PULL_SET_MEM_CTX(ndr, r->forest, 0);
 
155
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->forest));
 
156
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->forest));
 
157
                        if (ndr_get_array_length(ndr, &r->forest) > ndr_get_array_size(ndr, &r->forest)) {
 
158
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->forest), ndr_get_array_length(ndr, &r->forest));
 
159
                        }
 
160
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->forest), sizeof(uint16_t)));
 
161
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->forest, ndr_get_array_length(ndr, &r->forest), sizeof(uint16_t), CH_UTF16));
 
162
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_0, 0);
 
163
                }
 
164
        }
 
165
        return NDR_ERR_SUCCESS;
 
166
}
 
167
 
 
168
_PUBLIC_ void ndr_print_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_print *ndr, const char *name, const struct dssetup_DsRolePrimaryDomInfoBasic *r)
 
169
{
 
170
        ndr_print_struct(ndr, name, "dssetup_DsRolePrimaryDomInfoBasic");
 
171
        ndr->depth++;
 
172
        ndr_print_dssetup_DsRole(ndr, "role", r->role);
 
173
        ndr_print_dssetup_DsRoleFlags(ndr, "flags", r->flags);
 
174
        ndr_print_ptr(ndr, "domain", r->domain);
 
175
        ndr->depth++;
 
176
        if (r->domain) {
 
177
                ndr_print_string(ndr, "domain", r->domain);
 
178
        }
 
179
        ndr->depth--;
 
180
        ndr_print_ptr(ndr, "dns_domain", r->dns_domain);
 
181
        ndr->depth++;
 
182
        if (r->dns_domain) {
 
183
                ndr_print_string(ndr, "dns_domain", r->dns_domain);
 
184
        }
 
185
        ndr->depth--;
 
186
        ndr_print_ptr(ndr, "forest", r->forest);
 
187
        ndr->depth++;
 
188
        if (r->forest) {
 
189
                ndr_print_string(ndr, "forest", r->forest);
 
190
        }
 
191
        ndr->depth--;
 
192
        ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
 
193
        ndr->depth--;
 
194
}
 
195
 
 
196
static enum ndr_err_code ndr_push_dssetup_DsUpgrade(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsUpgrade r)
 
197
{
 
198
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
199
        return NDR_ERR_SUCCESS;
 
200
}
 
201
 
 
202
static enum ndr_err_code ndr_pull_dssetup_DsUpgrade(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsUpgrade *r)
 
203
{
 
204
        uint32_t v;
 
205
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
206
        *r = v;
 
207
        return NDR_ERR_SUCCESS;
 
208
}
 
209
 
 
210
_PUBLIC_ void ndr_print_dssetup_DsUpgrade(struct ndr_print *ndr, const char *name, enum dssetup_DsUpgrade r)
 
211
{
 
212
        const char *val = NULL;
 
213
 
 
214
        switch (r) {
 
215
                case DS_ROLE_NOT_UPGRADING: val = "DS_ROLE_NOT_UPGRADING"; break;
 
216
                case DS_ROLE_UPGRADING: val = "DS_ROLE_UPGRADING"; break;
 
217
        }
 
218
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
219
}
 
220
 
 
221
static enum ndr_err_code ndr_push_dssetup_DsPrevious(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsPrevious r)
 
222
{
 
223
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
224
        return NDR_ERR_SUCCESS;
 
225
}
 
226
 
 
227
static enum ndr_err_code ndr_pull_dssetup_DsPrevious(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsPrevious *r)
 
228
{
 
229
        uint16_t v;
 
230
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
231
        *r = v;
 
232
        return NDR_ERR_SUCCESS;
 
233
}
 
234
 
 
235
_PUBLIC_ void ndr_print_dssetup_DsPrevious(struct ndr_print *ndr, const char *name, enum dssetup_DsPrevious r)
 
236
{
 
237
        const char *val = NULL;
 
238
 
 
239
        switch (r) {
 
240
                case DS_ROLE_PREVIOUS_UNKNOWN: val = "DS_ROLE_PREVIOUS_UNKNOWN"; break;
 
241
                case DS_ROLE_PREVIOUS_PRIMARY: val = "DS_ROLE_PREVIOUS_PRIMARY"; break;
 
242
                case DS_ROLE_PREVIOUS_BACKUP: val = "DS_ROLE_PREVIOUS_BACKUP"; break;
 
243
        }
 
244
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
245
}
 
246
 
 
247
static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeStatus(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRoleUpgradeStatus *r)
 
248
{
 
249
        if (ndr_flags & NDR_SCALARS) {
 
250
                NDR_CHECK(ndr_push_align(ndr, 4));
 
251
                NDR_CHECK(ndr_push_dssetup_DsUpgrade(ndr, NDR_SCALARS, r->upgrading));
 
252
                NDR_CHECK(ndr_push_dssetup_DsPrevious(ndr, NDR_SCALARS, r->previous_role));
 
253
        }
 
254
        if (ndr_flags & NDR_BUFFERS) {
 
255
        }
 
256
        return NDR_ERR_SUCCESS;
 
257
}
 
258
 
 
259
static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeStatus(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRoleUpgradeStatus *r)
 
260
{
 
261
        if (ndr_flags & NDR_SCALARS) {
 
262
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
263
                NDR_CHECK(ndr_pull_dssetup_DsUpgrade(ndr, NDR_SCALARS, &r->upgrading));
 
264
                NDR_CHECK(ndr_pull_dssetup_DsPrevious(ndr, NDR_SCALARS, &r->previous_role));
 
265
        }
 
266
        if (ndr_flags & NDR_BUFFERS) {
 
267
        }
 
268
        return NDR_ERR_SUCCESS;
 
269
}
 
270
 
 
271
_PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeStatus(struct ndr_print *ndr, const char *name, const struct dssetup_DsRoleUpgradeStatus *r)
 
272
{
 
273
        ndr_print_struct(ndr, name, "dssetup_DsRoleUpgradeStatus");
 
274
        ndr->depth++;
 
275
        ndr_print_dssetup_DsUpgrade(ndr, "upgrading", r->upgrading);
 
276
        ndr_print_dssetup_DsPrevious(ndr, "previous_role", r->previous_role);
 
277
        ndr->depth--;
 
278
}
 
279
 
 
280
static enum ndr_err_code ndr_push_dssetup_DsRoleOp(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleOp r)
 
281
{
 
282
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
283
        return NDR_ERR_SUCCESS;
 
284
}
 
285
 
 
286
static enum ndr_err_code ndr_pull_dssetup_DsRoleOp(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleOp *r)
 
287
{
 
288
        uint16_t v;
 
289
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
290
        *r = v;
 
291
        return NDR_ERR_SUCCESS;
 
292
}
 
293
 
 
294
_PUBLIC_ void ndr_print_dssetup_DsRoleOp(struct ndr_print *ndr, const char *name, enum dssetup_DsRoleOp r)
 
295
{
 
296
        const char *val = NULL;
 
297
 
 
298
        switch (r) {
 
299
                case DS_ROLE_OP_IDLE: val = "DS_ROLE_OP_IDLE"; break;
 
300
                case DS_ROLE_OP_ACTIVE: val = "DS_ROLE_OP_ACTIVE"; break;
 
301
                case DS_ROLE_OP_NEEDS_REBOOT: val = "DS_ROLE_OP_NEEDS_REBOOT"; break;
 
302
        }
 
303
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
304
}
 
305
 
 
306
static enum ndr_err_code ndr_push_dssetup_DsRoleOpStatus(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRoleOpStatus *r)
 
307
{
 
308
        if (ndr_flags & NDR_SCALARS) {
 
309
                NDR_CHECK(ndr_push_align(ndr, 2));
 
310
                NDR_CHECK(ndr_push_dssetup_DsRoleOp(ndr, NDR_SCALARS, r->status));
 
311
        }
 
312
        if (ndr_flags & NDR_BUFFERS) {
 
313
        }
 
314
        return NDR_ERR_SUCCESS;
 
315
}
 
316
 
 
317
static enum ndr_err_code ndr_pull_dssetup_DsRoleOpStatus(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRoleOpStatus *r)
 
318
{
 
319
        if (ndr_flags & NDR_SCALARS) {
 
320
                NDR_CHECK(ndr_pull_align(ndr, 2));
 
321
                NDR_CHECK(ndr_pull_dssetup_DsRoleOp(ndr, NDR_SCALARS, &r->status));
 
322
        }
 
323
        if (ndr_flags & NDR_BUFFERS) {
 
324
        }
 
325
        return NDR_ERR_SUCCESS;
 
326
}
 
327
 
 
328
_PUBLIC_ void ndr_print_dssetup_DsRoleOpStatus(struct ndr_print *ndr, const char *name, const struct dssetup_DsRoleOpStatus *r)
 
329
{
 
330
        ndr_print_struct(ndr, name, "dssetup_DsRoleOpStatus");
 
331
        ndr->depth++;
 
332
        ndr_print_dssetup_DsRoleOp(ndr, "status", r->status);
 
333
        ndr->depth--;
 
334
}
 
335
 
 
336
static enum ndr_err_code ndr_push_dssetup_DsRoleInfoLevel(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel r)
 
337
{
 
338
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
339
        return NDR_ERR_SUCCESS;
 
340
}
 
341
 
 
342
static enum ndr_err_code ndr_pull_dssetup_DsRoleInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel *r)
 
343
{
 
344
        uint16_t v;
 
345
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
346
        *r = v;
 
347
        return NDR_ERR_SUCCESS;
 
348
}
 
349
 
 
350
_PUBLIC_ void ndr_print_dssetup_DsRoleInfoLevel(struct ndr_print *ndr, const char *name, enum dssetup_DsRoleInfoLevel r)
 
351
{
 
352
        const char *val = NULL;
 
353
 
 
354
        switch (r) {
 
355
                case DS_ROLE_BASIC_INFORMATION: val = "DS_ROLE_BASIC_INFORMATION"; break;
 
356
                case DS_ROLE_UPGRADE_STATUS: val = "DS_ROLE_UPGRADE_STATUS"; break;
 
357
                case DS_ROLE_OP_STATUS: val = "DS_ROLE_OP_STATUS"; break;
 
358
        }
 
359
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
360
}
 
361
 
 
362
static enum ndr_err_code ndr_push_dssetup_DsRoleInfo(struct ndr_push *ndr, int ndr_flags, const union dssetup_DsRoleInfo *r)
 
363
{
 
364
        if (ndr_flags & NDR_SCALARS) {
 
365
                int level = ndr_push_get_switch_value(ndr, r);
 
366
                NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, level));
 
367
                switch (level) {
 
368
                        case DS_ROLE_BASIC_INFORMATION: {
 
369
                                NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 
370
                        break; }
 
371
 
 
372
                        case DS_ROLE_UPGRADE_STATUS: {
 
373
                                NDR_CHECK(ndr_push_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 
374
                        break; }
 
375
 
 
376
                        case DS_ROLE_OP_STATUS: {
 
377
                                NDR_CHECK(ndr_push_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 
378
                        break; }
 
379
 
 
380
                        default:
 
381
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
382
                }
 
383
        }
 
384
        if (ndr_flags & NDR_BUFFERS) {
 
385
                int level = ndr_push_get_switch_value(ndr, r);
 
386
                switch (level) {
 
387
                        case DS_ROLE_BASIC_INFORMATION:
 
388
                                NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 
389
                        break;
 
390
 
 
391
                        case DS_ROLE_UPGRADE_STATUS:
 
392
                        break;
 
393
 
 
394
                        case DS_ROLE_OP_STATUS:
 
395
                        break;
 
396
 
 
397
                        default:
 
398
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
399
                }
 
400
        }
 
401
        return NDR_ERR_SUCCESS;
 
402
}
 
403
 
 
404
static enum ndr_err_code ndr_pull_dssetup_DsRoleInfo(struct ndr_pull *ndr, int ndr_flags, union dssetup_DsRoleInfo *r)
 
405
{
 
406
        int level;
 
407
        uint16_t _level;
 
408
        level = ndr_pull_get_switch_value(ndr, r);
 
409
        if (ndr_flags & NDR_SCALARS) {
 
410
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
411
                if (_level != level) {
 
412
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
413
                }
 
414
                switch (level) {
 
415
                        case DS_ROLE_BASIC_INFORMATION: {
 
416
                                NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 
417
                        break; }
 
418
 
 
419
                        case DS_ROLE_UPGRADE_STATUS: {
 
420
                                NDR_CHECK(ndr_pull_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 
421
                        break; }
 
422
 
 
423
                        case DS_ROLE_OP_STATUS: {
 
424
                                NDR_CHECK(ndr_pull_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 
425
                        break; }
 
426
 
 
427
                        default:
 
428
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
429
                }
 
430
        }
 
431
        if (ndr_flags & NDR_BUFFERS) {
 
432
                switch (level) {
 
433
                        case DS_ROLE_BASIC_INFORMATION:
 
434
                                NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 
435
                        break;
 
436
 
 
437
                        case DS_ROLE_UPGRADE_STATUS:
 
438
                        break;
 
439
 
 
440
                        case DS_ROLE_OP_STATUS:
 
441
                        break;
 
442
 
 
443
                        default:
 
444
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
445
                }
 
446
        }
 
447
        return NDR_ERR_SUCCESS;
 
448
}
 
449
 
 
450
_PUBLIC_ void ndr_print_dssetup_DsRoleInfo(struct ndr_print *ndr, const char *name, const union dssetup_DsRoleInfo *r)
 
451
{
 
452
        int level;
 
453
        level = ndr_print_get_switch_value(ndr, r);
 
454
        ndr_print_union(ndr, name, level, "dssetup_DsRoleInfo");
 
455
        switch (level) {
 
456
                case DS_ROLE_BASIC_INFORMATION:
 
457
                        ndr_print_dssetup_DsRolePrimaryDomInfoBasic(ndr, "basic", &r->basic);
 
458
                break;
 
459
 
 
460
                case DS_ROLE_UPGRADE_STATUS:
 
461
                        ndr_print_dssetup_DsRoleUpgradeStatus(ndr, "upgrade", &r->upgrade);
 
462
                break;
 
463
 
 
464
                case DS_ROLE_OP_STATUS:
 
465
                        ndr_print_dssetup_DsRoleOpStatus(ndr, "opstatus", &r->opstatus);
 
466
                break;
 
467
 
 
468
                default:
 
469
                        ndr_print_bad_level(ndr, name, level);
 
470
        }
 
471
}
 
472
 
 
473
static enum ndr_err_code ndr_push_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 
474
{
 
475
        if (flags & NDR_IN) {
 
476
                NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, r->in.level));
 
477
        }
 
478
        if (flags & NDR_OUT) {
 
479
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
 
480
                if (r->out.info) {
 
481
                        NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
482
                        NDR_CHECK(ndr_push_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
483
                }
 
484
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
485
        }
 
486
        return NDR_ERR_SUCCESS;
 
487
}
 
488
 
 
489
static enum ndr_err_code ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 
490
{
 
491
        uint32_t _ptr_info;
 
492
        TALLOC_CTX *_mem_save_info_0;
 
493
        if (flags & NDR_IN) {
 
494
                ZERO_STRUCT(r->out);
 
495
 
 
496
                NDR_CHECK(ndr_pull_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 
497
        }
 
498
        if (flags & NDR_OUT) {
 
499
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
500
                if (_ptr_info) {
 
501
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
502
                } else {
 
503
                        r->out.info = NULL;
 
504
                }
 
505
                if (r->out.info) {
 
506
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
507
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 
508
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
509
                        NDR_CHECK(ndr_pull_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
510
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 
511
                }
 
512
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
513
        }
 
514
        return NDR_ERR_SUCCESS;
 
515
}
 
516
 
 
517
_PUBLIC_ void ndr_print_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 
518
{
 
519
        ndr_print_struct(ndr, name, "dssetup_DsRoleGetPrimaryDomainInformation");
 
520
        ndr->depth++;
 
521
        if (flags & NDR_SET_VALUES) {
 
522
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
523
        }
 
524
        if (flags & NDR_IN) {
 
525
                ndr_print_struct(ndr, "in", "dssetup_DsRoleGetPrimaryDomainInformation");
 
526
                ndr->depth++;
 
527
                ndr_print_dssetup_DsRoleInfoLevel(ndr, "level", r->in.level);
 
528
                ndr->depth--;
 
529
        }
 
530
        if (flags & NDR_OUT) {
 
531
                ndr_print_struct(ndr, "out", "dssetup_DsRoleGetPrimaryDomainInformation");
 
532
                ndr->depth++;
 
533
                ndr_print_ptr(ndr, "info", r->out.info);
 
534
                ndr->depth++;
 
535
                if (r->out.info) {
 
536
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
537
                        ndr_print_dssetup_DsRoleInfo(ndr, "info", r->out.info);
 
538
                }
 
539
                ndr->depth--;
 
540
                ndr_print_WERROR(ndr, "result", r->out.result);
 
541
                ndr->depth--;
 
542
        }
 
543
        ndr->depth--;
 
544
}
 
545
 
 
546
static enum ndr_err_code ndr_push_dssetup_DsRoleDnsNameToFlatName(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 
547
{
 
548
        if (flags & NDR_IN) {
 
549
        }
 
550
        if (flags & NDR_OUT) {
 
551
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
552
        }
 
553
        return NDR_ERR_SUCCESS;
 
554
}
 
555
 
 
556
static enum ndr_err_code ndr_pull_dssetup_DsRoleDnsNameToFlatName(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDnsNameToFlatName *r)
 
557
{
 
558
        if (flags & NDR_IN) {
 
559
        }
 
560
        if (flags & NDR_OUT) {
 
561
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
562
        }
 
563
        return NDR_ERR_SUCCESS;
 
564
}
 
565
 
 
566
_PUBLIC_ void ndr_print_dssetup_DsRoleDnsNameToFlatName(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 
567
{
 
568
        ndr_print_struct(ndr, name, "dssetup_DsRoleDnsNameToFlatName");
 
569
        ndr->depth++;
 
570
        if (flags & NDR_SET_VALUES) {
 
571
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
572
        }
 
573
        if (flags & NDR_IN) {
 
574
                ndr_print_struct(ndr, "in", "dssetup_DsRoleDnsNameToFlatName");
 
575
                ndr->depth++;
 
576
                ndr->depth--;
 
577
        }
 
578
        if (flags & NDR_OUT) {
 
579
                ndr_print_struct(ndr, "out", "dssetup_DsRoleDnsNameToFlatName");
 
580
                ndr->depth++;
 
581
                ndr_print_WERROR(ndr, "result", r->out.result);
 
582
                ndr->depth--;
 
583
        }
 
584
        ndr->depth--;
 
585
}
 
586
 
 
587
static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsDc *r)
 
588
{
 
589
        if (flags & NDR_IN) {
 
590
        }
 
591
        if (flags & NDR_OUT) {
 
592
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
593
        }
 
594
        return NDR_ERR_SUCCESS;
 
595
}
 
596
 
 
597
static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsDc *r)
 
598
{
 
599
        if (flags & NDR_IN) {
 
600
        }
 
601
        if (flags & NDR_OUT) {
 
602
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
603
        }
 
604
        return NDR_ERR_SUCCESS;
 
605
}
 
606
 
 
607
_PUBLIC_ void ndr_print_dssetup_DsRoleDcAsDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsDc *r)
 
608
{
 
609
        ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsDc");
 
610
        ndr->depth++;
 
611
        if (flags & NDR_SET_VALUES) {
 
612
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
613
        }
 
614
        if (flags & NDR_IN) {
 
615
                ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsDc");
 
616
                ndr->depth++;
 
617
                ndr->depth--;
 
618
        }
 
619
        if (flags & NDR_OUT) {
 
620
                ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsDc");
 
621
                ndr->depth++;
 
622
                ndr_print_WERROR(ndr, "result", r->out.result);
 
623
                ndr->depth--;
 
624
        }
 
625
        ndr->depth--;
 
626
}
 
627
 
 
628
static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsReplica(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 
629
{
 
630
        if (flags & NDR_IN) {
 
631
        }
 
632
        if (flags & NDR_OUT) {
 
633
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
634
        }
 
635
        return NDR_ERR_SUCCESS;
 
636
}
 
637
 
 
638
static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsReplica(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsReplica *r)
 
639
{
 
640
        if (flags & NDR_IN) {
 
641
        }
 
642
        if (flags & NDR_OUT) {
 
643
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
644
        }
 
645
        return NDR_ERR_SUCCESS;
 
646
}
 
647
 
 
648
_PUBLIC_ void ndr_print_dssetup_DsRoleDcAsReplica(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 
649
{
 
650
        ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsReplica");
 
651
        ndr->depth++;
 
652
        if (flags & NDR_SET_VALUES) {
 
653
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
654
        }
 
655
        if (flags & NDR_IN) {
 
656
                ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsReplica");
 
657
                ndr->depth++;
 
658
                ndr->depth--;
 
659
        }
 
660
        if (flags & NDR_OUT) {
 
661
                ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsReplica");
 
662
                ndr->depth++;
 
663
                ndr_print_WERROR(ndr, "result", r->out.result);
 
664
                ndr->depth--;
 
665
        }
 
666
        ndr->depth--;
 
667
}
 
668
 
 
669
static enum ndr_err_code ndr_push_dssetup_DsRoleDemoteDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDemoteDc *r)
 
670
{
 
671
        if (flags & NDR_IN) {
 
672
        }
 
673
        if (flags & NDR_OUT) {
 
674
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
675
        }
 
676
        return NDR_ERR_SUCCESS;
 
677
}
 
678
 
 
679
static enum ndr_err_code ndr_pull_dssetup_DsRoleDemoteDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDemoteDc *r)
 
680
{
 
681
        if (flags & NDR_IN) {
 
682
        }
 
683
        if (flags & NDR_OUT) {
 
684
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
685
        }
 
686
        return NDR_ERR_SUCCESS;
 
687
}
 
688
 
 
689
_PUBLIC_ void ndr_print_dssetup_DsRoleDemoteDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDemoteDc *r)
 
690
{
 
691
        ndr_print_struct(ndr, name, "dssetup_DsRoleDemoteDc");
 
692
        ndr->depth++;
 
693
        if (flags & NDR_SET_VALUES) {
 
694
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
695
        }
 
696
        if (flags & NDR_IN) {
 
697
                ndr_print_struct(ndr, "in", "dssetup_DsRoleDemoteDc");
 
698
                ndr->depth++;
 
699
                ndr->depth--;
 
700
        }
 
701
        if (flags & NDR_OUT) {
 
702
                ndr_print_struct(ndr, "out", "dssetup_DsRoleDemoteDc");
 
703
                ndr->depth++;
 
704
                ndr_print_WERROR(ndr, "result", r->out.result);
 
705
                ndr->depth--;
 
706
        }
 
707
        ndr->depth--;
 
708
}
 
709
 
 
710
static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationProgress(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 
711
{
 
712
        if (flags & NDR_IN) {
 
713
        }
 
714
        if (flags & NDR_OUT) {
 
715
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
716
        }
 
717
        return NDR_ERR_SUCCESS;
 
718
}
 
719
 
 
720
static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationProgress(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationProgress *r)
 
721
{
 
722
        if (flags & NDR_IN) {
 
723
        }
 
724
        if (flags & NDR_OUT) {
 
725
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
726
        }
 
727
        return NDR_ERR_SUCCESS;
 
728
}
 
729
 
 
730
_PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationProgress(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 
731
{
 
732
        ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationProgress");
 
733
        ndr->depth++;
 
734
        if (flags & NDR_SET_VALUES) {
 
735
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
736
        }
 
737
        if (flags & NDR_IN) {
 
738
                ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationProgress");
 
739
                ndr->depth++;
 
740
                ndr->depth--;
 
741
        }
 
742
        if (flags & NDR_OUT) {
 
743
                ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationProgress");
 
744
                ndr->depth++;
 
745
                ndr_print_WERROR(ndr, "result", r->out.result);
 
746
                ndr->depth--;
 
747
        }
 
748
        ndr->depth--;
 
749
}
 
750
 
 
751
static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationResults(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 
752
{
 
753
        if (flags & NDR_IN) {
 
754
        }
 
755
        if (flags & NDR_OUT) {
 
756
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
757
        }
 
758
        return NDR_ERR_SUCCESS;
 
759
}
 
760
 
 
761
static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationResults(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationResults *r)
 
762
{
 
763
        if (flags & NDR_IN) {
 
764
        }
 
765
        if (flags & NDR_OUT) {
 
766
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
767
        }
 
768
        return NDR_ERR_SUCCESS;
 
769
}
 
770
 
 
771
_PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationResults(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 
772
{
 
773
        ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationResults");
 
774
        ndr->depth++;
 
775
        if (flags & NDR_SET_VALUES) {
 
776
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
777
        }
 
778
        if (flags & NDR_IN) {
 
779
                ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationResults");
 
780
                ndr->depth++;
 
781
                ndr->depth--;
 
782
        }
 
783
        if (flags & NDR_OUT) {
 
784
                ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationResults");
 
785
                ndr->depth++;
 
786
                ndr_print_WERROR(ndr, "result", r->out.result);
 
787
                ndr->depth--;
 
788
        }
 
789
        ndr->depth--;
 
790
}
 
791
 
 
792
static enum ndr_err_code ndr_push_dssetup_DsRoleCancel(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleCancel *r)
 
793
{
 
794
        if (flags & NDR_IN) {
 
795
        }
 
796
        if (flags & NDR_OUT) {
 
797
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
798
        }
 
799
        return NDR_ERR_SUCCESS;
 
800
}
 
801
 
 
802
static enum ndr_err_code ndr_pull_dssetup_DsRoleCancel(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleCancel *r)
 
803
{
 
804
        if (flags & NDR_IN) {
 
805
        }
 
806
        if (flags & NDR_OUT) {
 
807
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
808
        }
 
809
        return NDR_ERR_SUCCESS;
 
810
}
 
811
 
 
812
_PUBLIC_ void ndr_print_dssetup_DsRoleCancel(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleCancel *r)
 
813
{
 
814
        ndr_print_struct(ndr, name, "dssetup_DsRoleCancel");
 
815
        ndr->depth++;
 
816
        if (flags & NDR_SET_VALUES) {
 
817
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
818
        }
 
819
        if (flags & NDR_IN) {
 
820
                ndr_print_struct(ndr, "in", "dssetup_DsRoleCancel");
 
821
                ndr->depth++;
 
822
                ndr->depth--;
 
823
        }
 
824
        if (flags & NDR_OUT) {
 
825
                ndr_print_struct(ndr, "out", "dssetup_DsRoleCancel");
 
826
                ndr->depth++;
 
827
                ndr_print_WERROR(ndr, "result", r->out.result);
 
828
                ndr->depth--;
 
829
        }
 
830
        ndr->depth--;
 
831
}
 
832
 
 
833
static enum ndr_err_code ndr_push_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 
834
{
 
835
        if (flags & NDR_IN) {
 
836
        }
 
837
        if (flags & NDR_OUT) {
 
838
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
839
        }
 
840
        return NDR_ERR_SUCCESS;
 
841
}
 
842
 
 
843
static enum ndr_err_code ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 
844
{
 
845
        if (flags & NDR_IN) {
 
846
        }
 
847
        if (flags & NDR_OUT) {
 
848
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
849
        }
 
850
        return NDR_ERR_SUCCESS;
 
851
}
 
852
 
 
853
_PUBLIC_ void ndr_print_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 
854
{
 
855
        ndr_print_struct(ndr, name, "dssetup_DsRoleServerSaveStateForUpgrade");
 
856
        ndr->depth++;
 
857
        if (flags & NDR_SET_VALUES) {
 
858
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
859
        }
 
860
        if (flags & NDR_IN) {
 
861
                ndr_print_struct(ndr, "in", "dssetup_DsRoleServerSaveStateForUpgrade");
 
862
                ndr->depth++;
 
863
                ndr->depth--;
 
864
        }
 
865
        if (flags & NDR_OUT) {
 
866
                ndr_print_struct(ndr, "out", "dssetup_DsRoleServerSaveStateForUpgrade");
 
867
                ndr->depth++;
 
868
                ndr_print_WERROR(ndr, "result", r->out.result);
 
869
                ndr->depth--;
 
870
        }
 
871
        ndr->depth--;
 
872
}
 
873
 
 
874
static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 
875
{
 
876
        if (flags & NDR_IN) {
 
877
        }
 
878
        if (flags & NDR_OUT) {
 
879
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
880
        }
 
881
        return NDR_ERR_SUCCESS;
 
882
}
 
883
 
 
884
static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleUpgradeDownlevelServer *r)
 
885
{
 
886
        if (flags & NDR_IN) {
 
887
        }
 
888
        if (flags & NDR_OUT) {
 
889
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
890
        }
 
891
        return NDR_ERR_SUCCESS;
 
892
}
 
893
 
 
894
_PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 
895
{
 
896
        ndr_print_struct(ndr, name, "dssetup_DsRoleUpgradeDownlevelServer");
 
897
        ndr->depth++;
 
898
        if (flags & NDR_SET_VALUES) {
 
899
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
900
        }
 
901
        if (flags & NDR_IN) {
 
902
                ndr_print_struct(ndr, "in", "dssetup_DsRoleUpgradeDownlevelServer");
 
903
                ndr->depth++;
 
904
                ndr->depth--;
 
905
        }
 
906
        if (flags & NDR_OUT) {
 
907
                ndr_print_struct(ndr, "out", "dssetup_DsRoleUpgradeDownlevelServer");
 
908
                ndr->depth++;
 
909
                ndr_print_WERROR(ndr, "result", r->out.result);
 
910
                ndr->depth--;
 
911
        }
 
912
        ndr->depth--;
 
913
}
 
914
 
 
915
static enum ndr_err_code ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 
916
{
 
917
        if (flags & NDR_IN) {
 
918
        }
 
919
        if (flags & NDR_OUT) {
 
920
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
921
        }
 
922
        return NDR_ERR_SUCCESS;
 
923
}
 
924
 
 
925
static enum ndr_err_code ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 
926
{
 
927
        if (flags & NDR_IN) {
 
928
        }
 
929
        if (flags & NDR_OUT) {
 
930
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
931
        }
 
932
        return NDR_ERR_SUCCESS;
 
933
}
 
934
 
 
935
_PUBLIC_ void ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 
936
{
 
937
        ndr_print_struct(ndr, name, "dssetup_DsRoleAbortDownlevelServerUpgrade");
 
938
        ndr->depth++;
 
939
        if (flags & NDR_SET_VALUES) {
 
940
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
941
        }
 
942
        if (flags & NDR_IN) {
 
943
                ndr_print_struct(ndr, "in", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 
944
                ndr->depth++;
 
945
                ndr->depth--;
 
946
        }
 
947
        if (flags & NDR_OUT) {
 
948
                ndr_print_struct(ndr, "out", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 
949
                ndr->depth++;
 
950
                ndr_print_WERROR(ndr, "result", r->out.result);
 
951
                ndr->depth--;
 
952
        }
 
953
        ndr->depth--;
 
954
}
 
955
 
 
956
static const struct ndr_interface_call dssetup_calls[] = {
 
957
        {
 
958
                "dssetup_DsRoleGetPrimaryDomainInformation",
 
959
                sizeof(struct dssetup_DsRoleGetPrimaryDomainInformation),
 
960
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetPrimaryDomainInformation,
 
961
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation,
 
962
                (ndr_print_function_t) ndr_print_dssetup_DsRoleGetPrimaryDomainInformation,
 
963
                false,
 
964
        },
 
965
        {
 
966
                "dssetup_DsRoleDnsNameToFlatName",
 
967
                sizeof(struct dssetup_DsRoleDnsNameToFlatName),
 
968
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDnsNameToFlatName,
 
969
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDnsNameToFlatName,
 
970
                (ndr_print_function_t) ndr_print_dssetup_DsRoleDnsNameToFlatName,
 
971
                false,
 
972
        },
 
973
        {
 
974
                "dssetup_DsRoleDcAsDc",
 
975
                sizeof(struct dssetup_DsRoleDcAsDc),
 
976
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsDc,
 
977
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsDc,
 
978
                (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsDc,
 
979
                false,
 
980
        },
 
981
        {
 
982
                "dssetup_DsRoleDcAsReplica",
 
983
                sizeof(struct dssetup_DsRoleDcAsReplica),
 
984
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsReplica,
 
985
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsReplica,
 
986
                (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsReplica,
 
987
                false,
 
988
        },
 
989
        {
 
990
                "dssetup_DsRoleDemoteDc",
 
991
                sizeof(struct dssetup_DsRoleDemoteDc),
 
992
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDemoteDc,
 
993
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDemoteDc,
 
994
                (ndr_print_function_t) ndr_print_dssetup_DsRoleDemoteDc,
 
995
                false,
 
996
        },
 
997
        {
 
998
                "dssetup_DsRoleGetDcOperationProgress",
 
999
                sizeof(struct dssetup_DsRoleGetDcOperationProgress),
 
1000
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationProgress,
 
1001
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationProgress,
 
1002
                (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationProgress,
 
1003
                false,
 
1004
        },
 
1005
        {
 
1006
                "dssetup_DsRoleGetDcOperationResults",
 
1007
                sizeof(struct dssetup_DsRoleGetDcOperationResults),
 
1008
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationResults,
 
1009
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationResults,
 
1010
                (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationResults,
 
1011
                false,
 
1012
        },
 
1013
        {
 
1014
                "dssetup_DsRoleCancel",
 
1015
                sizeof(struct dssetup_DsRoleCancel),
 
1016
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleCancel,
 
1017
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleCancel,
 
1018
                (ndr_print_function_t) ndr_print_dssetup_DsRoleCancel,
 
1019
                false,
 
1020
        },
 
1021
        {
 
1022
                "dssetup_DsRoleServerSaveStateForUpgrade",
 
1023
                sizeof(struct dssetup_DsRoleServerSaveStateForUpgrade),
 
1024
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleServerSaveStateForUpgrade,
 
1025
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade,
 
1026
                (ndr_print_function_t) ndr_print_dssetup_DsRoleServerSaveStateForUpgrade,
 
1027
                false,
 
1028
        },
 
1029
        {
 
1030
                "dssetup_DsRoleUpgradeDownlevelServer",
 
1031
                sizeof(struct dssetup_DsRoleUpgradeDownlevelServer),
 
1032
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleUpgradeDownlevelServer,
 
1033
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleUpgradeDownlevelServer,
 
1034
                (ndr_print_function_t) ndr_print_dssetup_DsRoleUpgradeDownlevelServer,
 
1035
                false,
 
1036
        },
 
1037
        {
 
1038
                "dssetup_DsRoleAbortDownlevelServerUpgrade",
 
1039
                sizeof(struct dssetup_DsRoleAbortDownlevelServerUpgrade),
 
1040
                (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade,
 
1041
                (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade,
 
1042
                (ndr_print_function_t) ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade,
 
1043
                false,
 
1044
        },
 
1045
        { NULL, 0, NULL, NULL, NULL, false }
 
1046
};
 
1047
 
 
1048
static const char * const dssetup_endpoint_strings[] = {
 
1049
        "ncacn_np:[\\pipe\\lsarpc]", 
 
1050
        "ncacn_np:[\\pipe\\lsass]", 
 
1051
        "ncacn_ip_tcp:", 
 
1052
        "ncalrpc:", 
 
1053
};
 
1054
 
 
1055
static const struct ndr_interface_string_array dssetup_endpoints = {
 
1056
        .count  = 4,
 
1057
        .names  = dssetup_endpoint_strings
 
1058
};
 
1059
 
 
1060
static const char * const dssetup_authservice_strings[] = {
 
1061
        "host", 
 
1062
};
 
1063
 
 
1064
static const struct ndr_interface_string_array dssetup_authservices = {
 
1065
        .count  = 1,
 
1066
        .names  = dssetup_authservice_strings
 
1067
};
 
1068
 
 
1069
 
 
1070
const struct ndr_interface_table ndr_table_dssetup = {
 
1071
        .name           = "dssetup",
 
1072
        .syntax_id      = {
 
1073
                {0x3919286a,0xb10c,0x11d0,{0x9b,0xa8},{0x00,0xc0,0x4f,0xd9,0x2e,0xf5}},
 
1074
                NDR_DSSETUP_VERSION
 
1075
        },
 
1076
        .helpstring     = NDR_DSSETUP_HELPSTRING,
 
1077
        .num_calls      = 11,
 
1078
        .calls          = dssetup_calls,
 
1079
        .endpoints      = &dssetup_endpoints,
 
1080
        .authservices   = &dssetup_authservices
 
1081
};
 
1082